Creating Controls

Lesson 1 – GDI+

• GCI+ = .net managed implementation of GDI

System.Drawing Namespace

• Summary

  • System.Drawing – most of classes actually involved with rendering to screen

  • System.Drawing.Design – extend design time UI

  • System.Drawing.2D – advanced visual effects

  • System.Drawing.Imaging – manipulation of image files

  • System.Drawing.Printing – print support

  • System.Drawing.Text – font manipulation

System.Drawing.Graphics Object

• Principle object in rendering graphics

• Represents drawing surface of visual element, e.g. form, control, Image, etc.

• Can not directly instantiate – call CreateGraphics method on class deriving from Control

• When working with Image can obtain from static Graphics.FromImage method

System.Drawing.Graphics myFormGraphics;

myFormGraphics = myForm.CreateGraphics();

Bitmap myImage = new Bitmap(“C:\\myImage.bmp”);

System.Drawing.Graphics myBmpGraphics;

myBmpGraphics = Graphics.FromImage(myImage);

Coordinates

• Rendering occurs in region set by control bounds

• Origin = upper left hand corner

• Measured in screen pixels

• Variety of structures describe location in region

  • Point – single point with int values for X and Y

  • PointF – single point with float values for X and Y

  • Size – rectangular size consisting of paired height and width values as integers

  • SizeF - rectangular size consisting of paired height and width values as float

  • Rectangle – top, bottom, left and right edges specified by int values

  • RectangleF – top, bottom, left and right edges specified by float values

• Integral locations can be implicitly converted to floating-point counterparts

• To convert floating-point to integer locations must explicitly convert each point

• Note size structure indicate size, but not position

• Create rectangle by supplying Size and Point (upper left hand corner)

Point myOrigin = new Point(10,10);

Size mySize = new Size(20,20);

Rectangle myRectangle = new Rectangle(myOrigin, mySize);

Drawing Shapes

• Graphics object contains many methods to render shapes on screen

• Those beginning Draw, e.g. DrawArc, DrawPie, draw line structures, outlines, etc.

• Those beginning Fill, e.g. FillRegion, FillRectangle, render solid shapes

• Methods take parms specifying coordinates and location of shape to draw. Also require object to perform rendering – a Pen for Draw… and Brush for Fill…

Colors, Brushes, Pens

• System.Drawing.Color represent single color. Specified by 4 values – alpha which specifies transparency and Red, Green and blue values. Each value in range 0 to 255

• Can also specify named colours, e.g. Color.Tomato

• All brushes derive from abstract Brush class

  • System.Drawing.SolidBrush – single solid colour

  • System.Drawing.TextureBrush – fills object with an image

  • System.Drawing.Drawing2D.HatchBrush – fills with hatch pattern

  • System.Drawing.Drawing2D.LinearGradientBrush – blends 2 colours along a gradient

  • System.Drawing.Drawing2D.PathGradientBrush – render complex gradient

• Only one Pen class and it cannot be inherited. When create specify colour and width

• Use SystemColors, SystemPens and SystemBrushes class to ensure UI has same look and feel as rest of system, e.g. Highlight text colour available from System.Colors.HighlightText

Rendering

• Always Dispose of graphics objects when finished – use a lot of resources, failure to do so -> application degredation

SolidBrush myBrush = new SolidBrush(Color.MintCream);

Graphics g = this.CreateGraphics();

Rectangle myRectangle = new Rectangle(0, 0, 30, 20);

g.FillElipse(myBrush, myRectangle);

g.Dispose();

myBrush.Dispose();

• To render text

  • Create Font and Brush objects

  • Obtain reference to Graphics object

  • Call Graphics.DrawString specifying string, font, brush and location

  • Dispose of objects

• Complex Shapes

  • Obtain reference to Graphics object

  • Create instance of GraphicsPath class

  • Add figures to GraphicsPath

  • Call Graphics.DrawPath to draw path outline or Graphics.FillPath to fill shape

  • Dispaose of Graphics object

• The GraphicsPath object describes any complex closed shape or set of shapes

GraphicsPath myPath = new GraphicsPath(new Point[] {new Point(1,1), new Point(32,54), new Point(33,5)}, new byte[] {(byte)PathPointType.Start, (byte)PathPointType.Line, (byte)PathPoint.Bezier});

• Add figures to path using methods such as

  • GraphicsPath.AddClosedCurve

  • GraphicsPath.AddElipse

  • GraphicsPath.AddPie

  • GraphicsPath.AddString

  • …

• Can create figures by adding lines, arcs, curves, etc.

  • Begin by calling GraphicsPath.StartFigure

  • Add lines

    • AddArc

    • AddCurve

    • AddLine

  • Optionally call GraphicsPath.CloseFigure (if not called figure is closed at run time by drawing line from first point to last)

Lesson 2 – Authoring Controls

Inheritance

• All controls inherit (directly or indirectly) from Control class

  • Provides low level logic for UI and common control methods

  • No code to render control

  • No code to provide unique functionality

• Inherit from existing control = easiest way create new control

  • Inherits functionality and appearance

  • Can inherit from most Windows Forms controls (other than those marked sealed)

  • Use if retaining look and functionality of existing control but with some custom additions

  • Use if wish to retain functionality of existing control but a new look

  • Do not use if need radically different functionality

• Inherit from UserControl

  • Single control may not provide all functionality required, e.g. want control bound to data source that shows first name, last name and phone number in separate TextBox

  • Rather than implement logic in form can group multiple Windows Form controls into single unit (User Control)

  • Sometimes called Composite Control

  • UserControl provides base functionality

    • UserControl designer allows other Windows Form controls to be added and custom functionality implemented

    • Limited customisation of UI – just configuring ands positioning constituent controls

  • Use when need to combine functionality of multiple existing controls and additional logic as single unit

• Inherit from Control

  • Create custom control if rich UI or functionality unachievable via other inheritance mencahisms

  • Must program logic specific to control and code required to render visual representation

• Additional members

  • Add to control in same way as add to class (at any access level)

  • Form hosting control has access to public members

  • Public properties are automatically displayed in Properties window (unless Browsable attribute is false)

[System.ComponentModel.Browsable(false)]

public int StockNumber

{

}

Create Inherited Control

• Can either add new functionality or override members exposed by base class

public class NumberBox : System.Windows.Forms.TextBox

{

protected override void

OnKeyPress(KeyPressEventArgs e)

{

if(char.IsNumber(e.KeyChar) == false)

e.Handled = true;

}

}

• Override OnPaint method to modify control appearance, e.g to create button rendered as string of text

public class Wowbutton : System.Windows.Forms.Button

{

protected override void

OnPaint(PaintEventArgs pe)

{

System.Drawing.Drawing2D.GraphicsPath myPath = new System.Drawing.Drawing2D.GraphicsPath();

myPath.AddString(“Wow!”, Font.Family, (int)Font.Style, 72, new PointF(0,0), StringFormat.GenericDefault);

Region myRegion = new Region(myPath);

this.Region = myRegion;

}

}

• Note some controls, e.g. TextBox, drawn by form they exist on and not by the control itself, thus Paint() never called.

Creating UserControl

• Create class derived from UserControl

• Add Windows Form controls via UserControl designer

• Expose any appropriate properties from constituent controls

• Write custom functionality for user control

• Constituent controls are treated as private

• If want to allow other developers to change properties of constituent controls must selectively expose them through properties of the user control

public color ButtonColor

{

get

{

return Button1.BackColor;

}

set

{

Button1.BackColor = value;

}

}

• Can expose entire constituent control by changing Modifiers property to desired access level. Property only available in Properties window – does not exist at runtime.

Creating Custom Control

• Most customisable and configurable, but most time consuming to develop

• Must write all code to render visual representation – most time-intensive part of control development

• Default handler for Paint event is OnPaint() method

• Coordinates measured relative to upper left corner of control

protected override void OnPaint(PaintEventArgs e)

{

Brush aBrush = new SolidBrush(Color.Red);

Rectangle clientRectangle = new Rectangle(new

Point(0,0), this.Size);

e.Graphics.FillEllipse(aBrush, clientRectangle);

}

• When control resized ClipRectangle resized but control not necessarily redrawn. Can force redraw by using Control.SetStyle to set ResizeRedraw flag to true

• Can manually cause redraw by calling Refesh method

Lesson 3 – Using Controls

Adding to Toolbox

• Right click toolbox, choose Customize

• Choose .NET Framework Components Tab and click Browse

• Select DLL or EXE containing control

• Control is added to toolbox

Providing Toolbox Bitmap

• VisualStudio provide default icon bitmap for custom controls in toolbox

• Specify custom bitmap viaToolboxBitmapAttribute class

  • Specify 16 by 16 pixel bitmap to use or

[ToolboxBitmap(@”C:\Pasta.bmp”)

public class PastaMaker : Control

{

}

• Specify a type – custom control will have same Toolbox bitmap as that of specified type

[ToolboxBitmpa(typeof(Button))]

public class myButton : Button

{

}

Debugging Control

• Controls are not stand-alone projects – must be hosted within Windows Form project while debugging

• If control part of executable project – add new Windows Form to project to hold control

• If control part of non-executable project (e.g. class library) – add additional project to solution to test control

Licensing

• .NET provides built-in license management

• Default licensing model requires any control to be licensed to have LicenseProviderAttribute applied to it

  • Specifies LicenseProvider to use for validating license

  • LicenseProvider = abstract class providing standard interface for validation

  • In control constructor call LicenseManager.Validate to return reference to valid license – if control not licensed it will fail to load

• LicenseManager.Validate validates license by calling LicenseProvider.GetLicense – retrieves license and checks validity by calling LicenseProvider.IsKeyvalid

• Validation scheme depends on LicenseProvider implementation

  • .NET Framework includes implementation of LicesneProvider called LicFileLicenseProvider

  • GetLicense method of LicFileLicenseProvider searches for text file named <FullName>.LIC (where FullName = fully qualified control name)

  • Can override to provide own validation logic

  • Implement dispose for every licensed control

[LicenseProvider(typeof(LicFileLicenseProvider))]

public class Widget : System.Windows.Forms.Control

{

private License myLicense;

public Widget()

{

myLicense =

LicenseManager.Validate(typeof(Widget),

this);

}

protected override void Dispose(bool Disposing)

{

if(myLicense != null)

{

myLicense.Dispose();

myLicense = null;

}

}

}

Hosting in IE

• Every Windows Forms control can be hosted within IE

• To host in IE, control must be installed in

  • Global Assembly cache

  • same virtual directory as HTML page it is declared in

• Add to HTML page via <OBJECT> tag which specifies controls classid

• Classid = 2 parts

  • Path to file containing control

  • Fully qualified name of control

<OBJECT id=”myControl” classid=”http:ControlLibrary.dll#ControlLibrary1.myControl” VIEWASTEXT>

</OBJECT>