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>