Chapter 2 - Designing with Classes
and Tiers
byMatthew MacDonald 
Apress 2002
Companion Web
The Last Word
Three-tier design is an abstraction. No successful application will implement it exactly. However, it's also a powerful guideline that helps you shape how classes interact in your application. It may seem strange to start talking
about DataSets and business objects in a book on user interface design. (In fact, there are other excellent .NET books written entirely about data access.) But as you'll see, when you set specific rules about how the user
interface tier can communicate with other parts of your program, you start to make the transition from a simple collection of objects to a true user interface framework.
The following chapters of this book focus on mastering the tools of .NET user interfaces. Considerations for design and user interface architecture crop up periodically, but they take a back seat to the amazing new programming
model of .NET. This chapter was designed to give you the background in application architecture that you need to understand this "other layer." If you keep the considerations of this chapter in mind as you continue reading, you'll
discover an entirely new and richer way to program user interfaces.
This chapter also introduced you to the broad picture of user interface in the .NET world, and the basic design assumptions that Visual Studio .NET makes automatically. These decisions can be altered, and the .NET framework
itself allows you a considerable amount of freedom to create the exact framework that you want. In later chapters you'll learn how to exploit this freedom to create all types of custom controls.
Convert pdf to powerpoint with - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
adding pdf to powerpoint; changing pdf to powerpoint file
Convert pdf to powerpoint with - VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
convert pdf file to ppt online; how to change pdf file to powerpoint
Chapter 3 - Control Class Basics
byMatthew MacDonald 
Apress 2002
Companion Web
Chapter 3: Control Class Basics
This chapter explores the Control class, which provides basic functionality for the family of Windows controls. You will learn about fundamental topics like mouse and keyboard handling, focus, and control relations. Along the way,
I'll also introduce some important pieces of the System.Drawing namespace that allow you to create structures that represent colors, fonts, rectangles, and points.
The Windows Forms Package
.NET provides two toolkits for user interface design: one for web applications, and one for Windows development. This chapter introduces the Windows Forms package, which allows you to create the traditional rich graphical
interfaces found in everything from office productivity software to arcade games. The one detail that all these applications have in common is the fact that they are built out of windows-tiny pieces of screen real estate that can
present information and receive user input.
It's easy to imagine that "Windows Forms" refers to a special part of the .NET class library, where fundamental classes like Form and Control are stored. This is true, but it isn't the whole story. More accurately, Windows Forms
is the technology that allows the Common Language Runtime to interact with control objects and translate them into the low-level reality of the Windows operating system. In other words, you create objects that represent controls
and windows, and the Common Language Runtime handles the details like routing messages, keeping track of window handles, and calling functions from the Windows API.
This idea isn't new. In the past, developers have used the MFC framework in C++, WFC in J++, and Visual Basic's own "Ruby" forms engine to insulate themselves from some of the low-level details of Windows programming.
These frameworks all provide an object-oriented wrapper around the Windows API (which, on its own, is a disorganized collection holding hundreds of miscellaneous C routines). These frameworks were well intentioned, but they
have all suffered from a few problems.
Lack of consistency. If you learn how to use MFC, you still won't know anything about creating Visual Basic user interfaces. Even though every framework ultimately interacts with the Windows API, they have
dramatically different object models and philosophies. 
Thin layer/thick layer problems. Frameworks tend to be either easy to use, or powerful, but not both. MFC is really only a couple of steps away from Windows messages and low-level grunt work. On the other hand,
Visual Basic developers have the benefit of a simple framework, but face the lingering dread that they will need to delve into the raw Windows API for complex or unusual tasks that are beyond Visual Basic's bounds.
Subjugation to Windows API rules. The Windows API dictates certain harsh realities. For example, once you create a fixed-border window, you can't make its border resizable. These limitations make sense based
on how the Windows API is organized, but they often lead to confusing inconsistencies in a framework's object model.
The result of these limitations is that there are essentially two types of frameworks: those that are complicated to use for simple tasks (like MFC), and those that are easy to use for simple tasks, but difficult or impossible to use
for complex tasks (like VB). These object models provide a modern way to code user interfaces, but many programmers wonder why they should abstract the Windows API when its restrictions remain.
The .NET Solution
.NET addresses these problems by becoming more ambitious. The result is a user interface framework that uses some innovative sleight-of-hand to perform tasks that are difficult or impossible with the Windows API. Here are
some examples- tasks that .NET can perform but the Windows API cannot:
Change fixed style properties like the selection type of a list box or the border type of a window.
Change a form's owner.
Move an MDI child window from one MDI parent window to another.
Transform an MDI child window into an MDI parent and vice versa.
Move controls from one window to another.
Clearly this list includes a couple of tricks that a self-respecting application will probably never need to use. Still, they illustrate an important fact: .NET doesn't just provide an easier object model to access the Windows API; it
also provides capabilities that extend it. The result is a framework that works the way you would intuitively expect it to work based on its objects.
The samples for this chapter include a project called ImpossibleAPI, which shows one of these
"broken rules"-a child window that can jump between different MDI parents whenever the user clicks a
All of this raises an interesting question. How can a programming model built on the Windows API actually perform feats that the Windows API can't? Truthfully, there's nothing in the preceding list that couldn't be simulated with
the Windows API with a fair bit of effort. For example, you could appear to change the border style of a window by destroying and recreating an identical window. To do so you would have to rigorously track and restore all the
information from the previous window.
In fact, this is more or less what takes place in .NET. If you examine the control or window handle (the numeric value that identifies the window to the operating system), you'll see that it changes when you perform these unusual
operations. This signifies that, on an operating system level, .NET actually provides you with a new window or control. The difference is that .NET handles this destruction and re-creation automatically. The illusion is so perfect that
it's hardly an illusion at all (any more than the illusion that .NET web controls can maintain state, or that television shows continuous movement, rather than just a series of still images).
Online Convert PowerPoint to PDF file. Best free online export
Download Free Trial. Convert a PPTX/PPT File to PDF. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
how to add pdf to powerpoint; convert pdf to powerpoint presentation
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
converting pdf to ppt online; how to convert pdf into powerpoint on
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Convert PDF to Image; Convert Word to PDF; Convert Excel to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF;
how to convert pdf to ppt online; change pdf to powerpoint
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Convert PDF to HTML. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF to HTML. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
image from pdf to ppt; pdf page to powerpoint
Chapter 3 - Control Class Basics
byMatthew MacDonald 
Apress 2002
Companion Web
The Control Class
Chapter 2 introduced .NET control classes, and examined their place in the overall architecture of an application. To summarize:
You create and manipulate controls and forms using .NET classes. The Common Language Runtime recognizes these classes, and handles the low-level Windows details for you.
You use a control from the .NET class library by creating an instance of the appropriate class, and adding it to the Controls collection of a container control, like a panel or form. Whether you add the control at design-time or run-time, the task is the same.
You configure controls by setting properties. In addition, you can react to control events in two ways: by creating an event handler (typically in the Form class), or by deriving a custom control and overriding the corresponding method.
Every .NET control derives from the base class System.Windows.Forms.Control. Depending on the complexity of the control, it may pass through a few more stages in its evolution. Figure 3-1
Figure 3-1: Control hierarchy 
On its own, the Control class has no real purpose. It's mainly interesting for the basic functionality that it defines. Sorting through the functionality is no easy task. The 200+ members include countless properties, events that fire to notify you when most common properties are changed (like VisibleChanged, TextChanged, SizeChanged, and so on), and methods that
reset values to their defaults, along with some more useful and unusual members. The sections in this chapter sort through many of the properties under broad topic-specific headings like "color" and "focus." Before you begin your exploration, you may want to check out some of the basic and system-related members in Table 3-1
Table 3-1: Basic Control Members 
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. C# Demo: Convert PowerPoint to PDF Document. Add references: RasterEdge.Imaging.Basic.dll.
pdf picture to powerpoint; picture from pdf to powerpoint
C# PDF Convert to HTML SDK: Convert PDF to html files in
Convert PDF to HTML. |. C#.NET PDF SDK - Convert PDF to HTML in C#.NET. How to Use C# .NET XDoc.PDF SDK to Convert PDF to HTML Webpage in C# .NET Program.
pdf to powerpoint; how to convert pdf to ppt
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
and paste pdf to powerpoint; how to convert pdf to powerpoint in
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
VB.NET PDF - Convert PDF to TIFF Using VB in VB.NET. Free VB.NET Guide to Render and Convert PDF Document to TIFF in Visual Basic Class.
convert pdf into powerpoint; convert pdf pages into powerpoint slides
Chapter 3 - Control Class Basics
byMatthew MacDonald 
Apress 2002
Companion Web
Position and Size
A control's position is defined by the distance between its top-left corner and the top-left corner of its container. Often, the container is a form, but it could also be a container control like a panel or group box. Similarly, the size is
measured as the width and height of the control from the top-left point. By convention, the position measurement is positive in the downward and rightward directions.
In the later chapters on GDI+, you will discover that it is possible to create specialized controls that
have irregular boundaries by using the Region property. Chapter 5 previews this technique with
irregularly shaped forms.
All values are integers measured in pixels. They are provided through several properties (including Top, Left, Right, and Bottom for position, and Width and Height for size), as shown in Figure 3-3
of these properties, the preferred way for setting position is by using the Location property with a Point structure. Similarly, the preferred way to define size is to use the Size property with a Size structure. These basic structures
originate from the System.Drawing namespace.
Figure 3-3: Control measurements 
The following code shows how you can set the location and size of a control using the Point and Size structures.
System.Drawing.Point pt = new System.Drawing.Point();
pt.X = 300;    // The control will be 300 pixels from the left
pt.Y = 500;    // The control will be 500 pixels from the top.
ctrl.Location = pt;
System.Drawing.Size sz = new System.Drawing.Size();
sz.Width = 500;
sz.Height = 60;
ctrl.Size = sz;
// Just for fun, set another control to have the same size.
ctrl2.Size = ctrl.Size;
By importing the System.Drawing namespace and using some handy constructors, you can simplify this code considerably.
Chapter 3 - Control Class Basics
byMatthew MacDonald 
Apress 2002
Companion Web
Every control defines a ForeColor and BackColor property. For different controls, these properties have slightly different meanings. In a simple control like a label or text box, the foreground color is the color of the text, while the
background color is the area behind it. These values default to the Windows system-configured settings.
Colors are specified as Color structures from the System.Drawing namespace. It's extremely easy to create a color object, because you have several different options. You can create a color using:
An ARGB (alpha, red, green, blue) color value. You specify each value as integer.
An environment setting from the current color scheme. You choose the correspondingly named property from the SystemColors class.
A predefined .NET color name. You choose the correspondingly named property from the Color class.
An HTML color name. You specify this value as a string using the Color-Translator class. 
An OLE color code. You specify this value as an integer (representing a hexa-decimal value) using the ColorTranslator class.
A Win32 color code. You specify this value as an integer (representing a hexadecimal value) using the ColorTranslator class.
The code listing that follows shows several ways to specify a color using the Color, ColorTranslator, and SystemColors types. In order to use this code as written, you must import the System.Drawing namespace.
// Create a color from an ARGB value
int alpha = 255, red = 0;
int green = 255, blue = 0;
ctrl.ForeColor = Color.FromARGB(alpha, red, green, blue);
// Create a color from an environment setting
ctrl.ForeColor = SystemColors.HighlightText;
// Create a color using a .NET name
ctrl.ForeColor = Color.Crimson;
// Create a color from an HTML code
ctrl.ForeColor = ColorTranslator.FromHtml("Blue");
// Create a color from an OLE color code
ctrl.ForeColor = ColorTranslator.FromOle(OxFF00);
// Create a color from a Win32 color code;
ctrl.ForeColor = ColorTranslator.FromWin32(0xA000);
The next code snippet shows how you can transform the KnownColors enumeration into an array of strings that represent color names. This can be useful if you need to display a list of valid colors (by name) in an application.
String[] colorNames;
colorNames = System.Enum.GetNames(typeof(KnownColor));
Changing a color name string back to the appropriate enumerated value is just as easy using the special static Enum.Parse() method. This method compares the string against all the available values in an enumeration, and
chooses the matching one.
Chapter 3 - Control Class Basics
byMatthew MacDonald 
Apress 2002
Companion Web
Fonts and Text
The Control object defines a Text property that is used by derived controls for a variety of purposes. For a text box, the Text property corresponds to the information displayed in the text box, which can be modified by the user. For
controls like labels, command buttons, or forms, the Text property refers to static descriptive text displayed as a title or caption.
The font of a control's text is defined by the Font property, which uses an instance of the System.Drawing.Font class. Note that a Font object does not just represent a typeface (like Tahoma). Instead, it encapsulates all details
about the font family, point size, and styles (like bold and italic).
// You can create a font with one of the 13 constructors.
ctrl.Font = new Font("Tahoma", 8, FontStyle.Bold);
A traditional default font for Windows programs is often Microsoft Sans Serif. However, newer
applications since Windows 98 consistently use the slightly more attractive Tahoma font (which is also
better for input, as it distinguishes between characters like a lowercase "l" and uppercase "I").You
should use the Tahoma font in your applications.
A Control.FontHeight property is also provided, which returns the height of your chosen font in pixels. This setting allows you to perform calculations when you are drawing special graphics or text on a control manually. For
example, you could manually space lines the appropriate amount when drawing text directly onto a form background.
Note that font families are set using a string, rather than a type-safe enumerated property. If you try to create an object using a name that does not correspond to an installed font, .NET automatically (and unhelpfully) defaults to
the Microsoft Sans Serif font. An error does not occur. You may want to explicitly check the Font.Name property to check if this automatic substitution has been made.
To determine what fonts are installed on the system, you can enumerate through them with the System.Drawing.Text.InstalledFontCollection class. The example below adds the name of every installed font to a list box.
InstalledFontCollection fonts = new InstalledFontCollection();
foreach (FontFamily family in fonts.Families)
The online samples for this chapter include a FontViewer utility that uses this technique to create a list of fonts. The user can choose a font from a drop-down list control, and a sample line of text will be painted directly on the
window (see Figure 3-5
). To perform the font painting, the application uses some of the GDI+ methods you'll see in Chapter 12.
Figure 3-5: A simple font viewer 
Note that the Font property does not always configure the appearance of the text in the control. For
example, the font of all windows is defined by the system and is unchangeable. Instead, the
Form.Font property defines the default font for all contained controls.
Access Keys
Some controls (namely buttons and menu items) allow a character in their caption to be highlighted and used as an access key. For example, button controls often underline one character in the caption. If the user presses the
Ctrl key and that character, the button is "clicked" automatically. To configure these shortcuts keys just add an ampersand (&) before the special letter, as in "Sa&ve" to make "v" the access key. (If you actually want to use an
ampersand, you'll need to include the text "&&".)
Documents you may be interested
Documents you may be interested