Welcome!

PowerBuilder in Action

Frederick Koh

Subscribe to Frederick Koh: eMailAlertsEmail Alerts
Get Frederick Koh via: homepageHomepage mobileMobile rssRSS facebookFacebook twitterTwitter linkedinLinkedIn


Related Topics: Enterprise Architecture, Enterprise Application Performance

Article

Writing COM Controls for PowerBuilder in C#

Property Pages, Persistence, and Registration Free Deployment

While there is literature describing how to use .NET controls in PB (see for example, past issues of this magazine), all are silent on how to set control properties at runtime and how to persist them. This article will address both issues.

Like regular OLE controls, you can allow your .NET control properties to be set at design-time by means of property pages (see Figure 1).

Sample Code in PB12 Resource Page
The ideas in this article have been implemented in source code available at the PB12 Resource (http://www.sybase.com/powerbuilder12). Look for "Writing A COM Control for PB using C# Part 6." This article will reference it.

Required COM Interfaces
The COM interfaces required for OLE Control property pages are the same as those required by .NET controls. The only difference being that you can implement them in C# (or VB.NET).

The interfaces required are ISpecifyPropertyPages and IPropertyPage (see Figure 2)

The ISpecifyPropertyPages interface must be implemented by the control itself. By implementing the ISpecifyPropertyPages interface, a control indicates to the hosting IDE that it supports property pages. The Control can specify any number of property pages by providing their GUIDs in the implementation of the GetPages method of ISpecifyPropertyPages. Each "page" is a tab on the property tab dialog. In Figure 3, you would get two tabs on the dialog.

For each tab on the property page dialog, you need a COM object that implements the IPropertyPage interface. In our case this would be a C# (or VB.NET) object implementing the  IPropertyPage interface (see Figures 4 and 5). This object does not have to be a control. It just needs to be a COM creatable object with GUIDs that match those specified in the implementation of ISpecifyPropertyPages (the GetPages method).

The object implementing the IPropertyPage interface creates a Control to be parented to a hosting PB IDE dialog. This control is what appears in the tabs of the property page dialog. This is done through the Activate method of the IPropertyPage interface. The title of the hosting tab page can be specified in the GetPageInfo method.  In Figure 6, a PropertyGrid control is created and made a child window of the window passed in from the Activate method. In Figure 7, the hosting tab page has its title set.

The property page will need a reference to the control being designed (whose properties are being set through the property page). This reference is needed so that when you click the "OK" button on the property page, your code can synchronize the properties of the control to the values set through the property pages (see Figure 8). This is provided for by the SetObjects method of the IPropertyPage interface.

The synchronization of the values in the property page and the property values of the control when you click the "OK" or "Apply" button is done in the Apply method of the IPropertyPage interface.

The .NET PropertyGrid Control as a Property Page
One of the advantages of implementing property pages in C# is the greater ease with which the UI can be implemented. The .NET PropertyGrid control provides (out of the box) a GUI for editing properties of .NET objects (see Figure 9). It can be customized declaratively per property using attributes on properties. It can also launch customized dialogs for properties with the System.Drawing.Design.UITypeEditor attribute. The SelectedObject property of the PropertyGrid contains the object whose properties are being edited. The property values of the object are set immediately when set in the PropertyGrid. But we want the properties to be set only when we click "OK", and not immediately, and not at all when we click "Cancel." The solution is to avoid setting the SelectedObject property to the Control. Define another object to hold the same visible properties as the control and use that object as SelectedObject instead. Synchronization between the object and the control is done during the launching of the property page dialog and when "OK" is clicked.

Alternatives to the .NET PropertyGrid
While the PropertyGrid control is the most convenient way to provide a UI to edit .NET properties, you are not limited to it. You can use Window Forms UserControls or WPF UserControls hosted in an ElementHost in a Windows Forms UserControl. The code in Figures 10 and 11 has examples of both.

Persistence
Control properties set at design-time need to be saved, so that they can be reloaded at the next design session and also at runtime. There is good news here! Control properties that are public, "scalar" (strings, numbers or enumerations) and not named "Text" (!) are automatically persisted without you having to do anything. It is also possible to suppress the persistence of selected properties. To suppress persistence for a given property, use the System.ComponentModel.DesignerSerializationVisibility attribute on the property.

Persistence of "Non-scalar" Type Properties
This is another area where the comprehensiveness of the .NET Framework makes it easy to implement COM. The framework provides several ways to turn an object into a stream of bytes and back. The most convenient form of streams of bytes for our purpose is the string. A way of doing this is with the TypeConverter: turn your properties into strings properties using System.ComponentModel.TypeConverter. See Figure 12 for an example of this.

Another approach is to use XAML as the persistence format (see Figure 13).

Conclusion
Also in the sample code are examples on how to make Control backgrounds transparent at design-time. With this article, you have everything you need to create COM controls written in C#, lacking neither runtime nor design-time features.

For those who don't like the use of "regasm" for deployment, the registration-free option is also available. See http://msdn.microsoft.com/en-us/library/ms973915.aspx for pointers on how to write the required manifests and http://blogs.msdn.com/b/astebner/archive/2006/02/28/541036.aspx on how to embed manifests as resources.

More Stories By Frederick Koh

Frederick Koh is a Staff Engineer at Sybase, Inc., and has been a member of the PowerBuilder and DataWindow.NET development team since 2005. Frederick has over 14 years of IT industry experience.

Comments (0)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.