SRP Product News

SRP Utilities Update, Version 1.3

Kevin Fournier — Tue, 06 Jul 2010 13:43:41 -0500

Once again SRP delivers features that OpenInsight developers can really use. We begin by addressing what amounts to be a branding and marketing problem for software products based upon OpenInsight. The issue occurs when Windows groups icons in the taskbar. Once this occurs, the button's title becomes "oinsight", even if the application was using the SRP Application Launcher utility. This is undesirable for commercial products since users usually have no idea what "oinsight" is. With the new SRP_Taskbar method we can alter the group button text to be anything we wish, thus preserving a software product's essential branding.

It's important to note that setting the taskbar group title only works in Windows Vista and earlier. Windows 7 uses an entirely different protocol for it's taskbar, and a solution is in the works. Look for it in the 1.3.1 release.

Also new to this version of SRP Utilities is the SRP_TcpClient method. It creates a TCP/IP connection to a running server and sends data. It's very low level and designed for those that have no other API to access a server. We have plans to augment the method with server-specific functions to simplify use. For example, SRP_TcpClient has special commands for communication with the SRP Engine Service. Likewise, we would like to add support for the OEngineServer and other TCP/IP protocols.

Lastly, we've improved both SRP_Join_Arrays and SRP_Sort_Array. SRP_Join_Array now supports two more merge options: NOT and XOR. The NOT operation keeps everything in the first list that doesn't appear in the second list. The XOR operation returns all items that appear in one list or the other, but not both. Combined with the existing operations (AND and OR), this should cover all the ways in which you might want to combine a list of keys. SRP_Sort_Array has been improved in the way it performs right-aligned sorting. Originally, it would convert the column into floating point numbers and compare, but this would not work with data that had alphabetic characters. For example, it wouldn't correctly sort "Box 1", "Box 2", ... "Box 10". SRP_Sort_Array now performs true right-aligned sorting in the event that it cannot convert the data into binary floating point numbers.

If you are currently using version 1.2.3 or earlier, we highly recommend upgrading. Both existing users and those that wish to try this free utility can download the latest version of SRP Utilities from here.

SRP Editor Update, Version 2.3.5 & 2.3.6

Kevin Fournier — Mon, 25 Jan 2010 12:31:30 -0600

The SRP Editor saw a new update last week, another minor fix to the code formatter, resulting in version 2.3.5. However, before we could get around to announcing it, we made a much needed improvement to the SRP Editor's command line.

Our command line has always suffered when it comes to executing built-in routines. To give you some background, when you run any routine, the SRP Editor command line opens the routine's object code and determines how many parameters the routine expects. If you pass too few parameters, the SRP Editor passes null values for all the missing parameters to avoid potential VNAV errors. This, of course, only works for routines that exist in object code and list their parameters. For all other routines, the SRP Editor command line just sends the parameters you provide.

This becomes a headache when using common built-in routines such as COPY_ROW. COPY_ROW hates missing parameters, and you'll get a VNAV error if you forget even one. If permitted, we'd like to appeal to the old saying, "Better late than never."

The SRP Editor 2.3.6 now ships with a default list of routines and their parameter counts. You can browse or modify this list in the new TCL tab of the Options dialog. Don't worry about modifying the list, the SRP Editor will never overwrite your changes. Most users will not really need this as the most important built-in routines are already there, including COPY_ROW.

SRP Editor 2.3.6 is now available to download from here.

SRP Editor Update, Version 2.3.4

Don Bakke — Mon, 14 Dec 2009 02:18:46 -0600

'Tis the season for...SRP Editor updates. One of our customers has a knack for finding issues with our code formatter. In this most recent scenario, it appears that our formatting logic was failing to ignore a "for" statement when it was located within a commented line. As a result the remaining code was being improperly intended. SRP Editor 2.3.4 has addressed this and is now available to download from here.

SRP Editor Update, Version 2.3.3

Don Bakke — Tue, 01 Dec 2009 20:36:10 -0600

We recently received a report that the SRP Editor would produce the above error message when attempting to close a record with unsaved changes. When we looked at the code we discovered that this issue would only happen when the Window -> Close All menu option was selected.

The fix required less effort than creating a new install. Nevertheless, we dislike problems with our products no matter how trivial they are. Therefore we have fixed this in SRP Editor 2.3.3 and posted it here.

As an added bonus, here is a little known tip that you might be interested in: from the SRP Editor use Shift-F7 to bring up the Viewer display (unless it is already visible then skip this step.) Then enter history in the Command Line. This will give you the change log for the SRP Editor broken down by version number:

SRP Utilities Update, Version 1.2.3

Kevin Fournier — Mon, 09 Nov 2009 16:06:45 -0600

SRP Utilities has been enhanced yet again with SRP_Join_Arrays. This function is useful for those of you that implement your own cross references. On several occasions, the developers at SRP Computer Solutions, Inc. have found themselves with two lists of keys they would like to merge. Sometimes, they need to get the keys that appear in both lists: an intersection. Other times, they need to merge both lists together without duplications: a union. SRP_Join_Arrays can do this for you at top speeds.

This version of SRP Utilities also contains a bug fix. SRP_Clean_Array has a TRIM option that--per the documentation--is supposed to remove only trailing blank elements from the array. This was not happening. Instead, it was removing all blanks in the array. This error has been corrected.

If you are currently using version 1.2.2 or earlier, we highly recommend upgrading. Both existing users and those that wish to try this free utility can download the latest version of SRP Utilities from here.

Did You Know - Managing RDKs from the SRP Editor

Kevin Fournier — Mon, 19 Oct 2009 17:30:56 -0500

Like most developers, the programmers at SRP Computer Solutions, Inc. love making tools that simplify complex tasks and make us more productive. With so many tools, it was only a matter of time before we created a tool to help manage our tools, specifically, the deployment of our tools.

Repository Deployment Kits (RDKs) are the means by which we deploy our tools such as SRP Editor, SRP Utilities, etc. As such, we found ourselves expending a lot of time and effort on just the RDK management. Maintaining RDKs requires several steps and a separate tool. Since we spend so much time in the SRP Editor, it seemed natural to enhance the SRP Editor with time saving RDK tools. This thought process led to the "Add to RDK" menu and the RDK command.

Add to RDK

The "Add to RDK" tool is accessed via the Tools menu or by pressing F6.

Doing so opens the "Add to Repository" dialog.

The purpose of this tool is to make it simple to add or remove a stored procedure to an existing Repository View. The process looks like this:

Open a Stored Procedure
Press F6 or choose the Tools -> Add to RDK menu
Use the check boxes to add/remove the active Stored Procedure to/from an RDK

In the screenshot above, you'll notice three check box columns. This allows you to specify which parts of the Stored Procedure are included in the RDK: Source, Debug, and Object. The screenshot shows a good example of this. Each of our tools has two RDK's, one that includes all source code, in case we need to deploy the source code to another environment for testing, and one without source code, which we deploy to the end users. Anytime I add a new stored procedure to a toolset, such as our SRP Utilities, I can quickly add it to the appropriate RDKs in just a couple easy steps.

You can also use this tool for Inserts:

Notice there is only one column, since there is no concept of object/debug code for inserts. You can also use the "Add to RDK" tool for Records:

Like inserts, there is only check box column. A record is either added to the RDK or it is not. Note that any records will be added to the repository view as an APPROW entity. We have plans to make this smarter in the future, but for now, if you need to add a popup, message box, or form to the RDK, you need to use the RDK tool built into OpenInsight.

RDK Command

The RDK command simplifies the process of exporting RDKs. Those familiar with OpenInsight's RDK tool have likely encountered the caveats involved in exporting an RDK to a folder. For example, the folder must already exist and be empty. The RDK command eliminates these quirks and provides a very powerful additional feature. First, let's look at the command line syntax:

RDK [INSTALL|EXTRACT] SourceList [(options)]

The RDK command's first parameter is optional (see the Installing RDKs section below) and it determines whether or not we are installing an RDK or creating one.

Installing RDKs

To install an RDK, the equivalent of running the "RUN RDKINSTALL" statement in OI, follow the RDK keyword with the INSTALL keyword or omit this parameter altogether. The SourceList portion of the statement is a list of paths containing the RDKs we wish to install. As the name suggests, you can install multiple RDKs in a single call. Both of the following command lines work:

RDK INSTALL "C:\RDK\SRP_Editor_Rdk" "C:\RDK\SRP_Utilities_Rdk"

RDK "C:\RDK\SRP_Editor_Rdk" "C:\RDK\SRP_Utilities_Rdk"

There are no options when installing RDKs. Simply provide the list of RDK paths. The quotes are only necessary if the paths contain spaces.

Extracting RDKs

To extract and RDK, you must include the EXTRACT keyword and a list of one or more RDK deployment definitions. Recall, the RDK's destination directory is defined in the deployment definition and is therefore not supplied in the RDK command. As an example, here is the command to deploy the SRP Editor:

RDK EXTRACT SRP_EDITOR

Now, as is, this command will operate exactly as the OI RDK tool, failing if the directory does not exist or is not empty. This is where the options come in. There are three options: C, S, and V. The "C" option clears the destination directory before extracting the RDK. The "S" option creates the directory if it does not already exist. So, to ensure a successful extraction every time, use this command:

RDK EXTRACT SRP_EDITOR (CS)

The "V" option is useful for creating RDKs that target multiple versions of OpenInsight. To illustrate, the SRP Editor is developed in OpenInsight 7.0, then extract using the "V" option to create 7.1, 7.2, and 8.0+ compatible versions of the RDK. What do we mean when we say compatible? First, any presentation server changes between version are taken into account. Thus, any forms created in 7.0 are form fixed in the 7.1 and later RDKs. Secondly, each RDK version is given the appropriate RDKMODULEINSTALL for that version.

NOTE: There are no currently no RDK versions created for 9.x because the 8.0 RDK works in those versions of OI as is.

A final point of interest is that the "V" option only creates RDKs starting with the version of OI from which the command is executed. That is, if you run the RDK EXTRACT command in OI 7.2, then the "V" option will only create the 7.2 and 8.0 RDKs. So, our final command can look like this:

RDK EXTRACT SRP_EDITOR (CSV)

And since a list of deployment definitions are supported, we can extract several of our tools in one call:

RDK EXTRACT SRP_EDITOR SRP_MAIL SRP_UTILITIES (CSV)

It's our hope you find either of these tools useful in your own environment. We welcome your feedback on how to improve these tools. If you haven't tried the SRP Editor, you can download a free trial from here.

Did You Know - Accessing Images from Compressed Folders

Don Bakke — Sat, 10 Oct 2009 11:16:29 -0500

OpenInsight's BITMAP property allows developers access images by path name or from within a resource file (.DLL or .EXE):

// Pull image from a path.
Set_Property(Ctrl, 'BITMAP', 'BMPS\Check.png')

// Pull image from a resource file.
Set_Property(Ctrl, 'BITMAP', 'Images.dll#check')

Storing images within a resource file makes an application more professional and prevents the curious end user from modifying the images stored on the hard drive. However, many developers are unfamiliar with the technology necessary to manage images from within a resource file. Most software development kits provide tools for this. If you are unfamiliar with (or would rather not learn) these SDKs there are simple utilities that can be downloaded to make this relatively easy (e.g. one that seems to work well is Resource Hacker.)

As might be expected, all SRP ActiveX image based properties can load images from a path or resource file. However, for developers who like the idea of using a single file to store all their images but would rather not fiddle with resource files there is another option: zip files. Developers can put all of their images into a zip file (aka compressed folder) and use the same syntax to reference them. The .zip extension can even be renamed to obscure this even more:

// Pull image from a zip file.
Set_Property(Ctrl, 'OLE.Images', 'Images.zip#check')

// Pull image from a zip file (extension renamed).
Set_Property(Ctrl, 'OLE.Images', 'Images.fil#check')

Don't forget that the entire SRP ActiveX control suite and OLE Help documentation can be downloaded from here. These are fully functional controls but will display an evaluation message without a license file.

Did You Know - Using the TabColors Property

Don Bakke — Sat, 10 Oct 2009 02:57:58 -0500

In a recent article we highlighted the stunning Color Fill feature that many developers might not have been aware of. Several controls were demonstrated in that article. One example that was not pictured was the SRP Tab control, which will be the focus of this article.

There are two reasons which inspired me to highlight the SRP Tab control. First, being one of our very first ActiveX controls, it has received very little attention in recent years. Second, while doing an application review the other day I came across a window that instantly caught my attention:

The gradient background made me wonder if this application was being developed in OpenInsight 9.x, since that is when Revelation introduced this feature. This is demonstrated below in the Report Builder Page Setup dialog:

However, I was pretty sure this application was not designed in OpenInsight 9.x. I checked the About box. Sure enough, version 8.0.1. I was then reminded of a color-based ActiveX property that we introduced with little fanfare: TabColors. Therefore, if I had forgotten about this feature in our own controls, it seemed like a good candidate for a new article.

The documentation on this property that comes with our ActiveX controls is pretty thorough. Therefore I will not attempt to duplicate the technical material that it contains. Rather, I hope that this article will present some visual examples that will inspire developers. However, the reader is advised to use discretion when it comes to using colors on such a large scale. I will also make the disclaimer that many of the color examples used below are more for demonstration purposes rather than out of personal preference.

One technique is to color each tab distinctly. This would be used to help the user make quick associations based on the color in addition to the tab caption or position:

Here is the code we used to create the above example:

Ctrl            = @Window : '.OLE_TAB'
Set_Property(Ctrl, 'OLE.AllowXPTheme', No$)
Colors          = ''
Colors<1, 2>    = 'Vertical(Gradient(LightSkyBlue L=80, LightSkyBlue L=90), Border(LightSkyBlue))'
Colors<2, 2>    = 'Vertical(Gradient(LightSkyBlue L=90, LightSkyBlue L=95), Border(LightSkyBlue))'
Colors<3, 2>    = 'Vertical(Gradient(LightSkyBlue L=85, LightSkyBlue L=95), Border(LightSkyBlue))'
Colors<4, 1>    = 'Gray'
Colors<4, 2>    = 'Vertical(Gradient(Gray L=80, Gray L=90), Border(Gray))'
Colors<5>       = 'Vertical(Gradient(LightSkyBlue L=95, LightSkyBlue L=80), Border(LightSkyBlue))'
Set_Property(Ctrl, 'OLE.TabColors[1]', Colors)
Swap 'LightSkyBlue' with 'MediumBlue' in Colors
Set_Property(Ctrl, 'OLE.TabColors[2]', Colors)
Swap 'MediumBlue' with 'Indigo' in Colors
Set_Property(Ctrl, 'OLE.TabColors[3]', Colors)

Another use for colored tabs is to make it easier to identify which tab is selected. With some visual themes this can be a little difficult as the selected tab lacks any significant features that make it stand out. In this example we allowed the non-selected tabs to retain their default colors. Only the selected tab and panel were asigned a custom scheme. Additionally we utilized the SelectedFont property to make the text bold for further emphasis:

Our code for this technique is a little simpler than before:

Ctrl            = @Window : '.OLE_TAB'
Set_Property(Ctrl, 'OLE.AllowXPTheme', No$)
Set_Property(Ctrl, 'OLE.SelectFont', @SVM : @SVM : 700)
Colors          = ''
Colors<3, 2>    = 'Vertical(Gradient(Green L=90, Green L=85), Border(Green))'
Colors<5>       = 'Vertical(Gradient(Green L=85, Green L=65), Border(Green))'
Set_Property(Ctrl, 'OLE.TabColors[All]', Colors)

One obvious difference between the gradient features of OpenInsight 9.x and the TabColors feature of the SRP Tab control is that the latter requires an actual tab (if only one) to be created. What if the developer wants the benefit of a gradient background without having to use a tab? With that question in mind we are pleased to announce two new properties that are being unveiled for the first time with this article: CustomPaneColor and FillParentBackground. Before demonstrating these properties let us first look at this window:

You'll notice that this dialog box has a rectangle that surrounds and highlights most of the controls. The background within this rectangle is nearly white whereas the rest of the form's background is the defalt system color. This effect is achieved by using the SRP Tab control with no tabs. That is, it is purely there for aesthetic purposes. In this case we are using the AllowXPTheme property so that the entire form remains theme friendly.

With the CustomPaneColor property we can now customize how this background will look. For instance, by turning off the AllowXPTheme property (which is necessary for any of the color oriented properties to work properly, see documentation under TabColors for further information), we can now pass in any valid color or color fill setting:

But what if we want to color the entire form with a custom color rather than just a defined rectangle? In other words, what if we want to have the same type of gradient background feature that OpenInsight 9.x supports? One way to achieve this is to size the SRP Tab control so that it is positioned as high as possible on the form and set the Height property to -1 so that it resizes itself (you'll also want to set the Autosize Width property of the OpenInsight OLE control as well.) This gets pretty close to the mark, but not 100%. Therefore, the FillParentBackground property was created to make this just right. All the developer needs to do is add this property to the existing code and the background fill transfers from the SRP Tab pane onto the form's background:

In the above examples I used the Select system color. We often use this color to ensure that our forms are theme friendly:

Ctrl = @Window : '.OLE_TAB'
Set_Property(Ctrl, 'OLE.AllowXPTheme', No$)
Color = 'Vertical(Gradient(Select L=95, Select L=80), Border(Select))'
Set_Property(Ctrl, 'OLE.CustomPaneColor', Color)
// Disable FillParentBackground to only fill within the Tab control's borders.
// Enable FillParentBackground to fill the entire form.
Set_Property(Ctrl, 'OLE.FillParentBackground', Yes$)

For the very creative developer multiple Tab controls can be used for some very interesting effects. One can be used to color the entire background of the form and others can be used as a pseudo-groupbox/panel display:

A few notes regarding the above example:

#	Comment
1	This is the form background created with the FillParentBackground property. Control: OLE_TAB_BACKGROUND
2	This is the SRP Tab panel background created with the CustomPaneColor property. Control: OLE_TAB_PANEL
3	This is the SRP Tab pseudo-groupbox background created with the CustomPaneColor property. Control: OLE_TAB_GROUP
4	These are SRP Button controls using the Background and Foreground properties.
5	This is the SRP ShortcutBar control with the Theme property set to WinXP.

Finally, here is the code for those interested in how this was put together:

// Make the form background a medium blue gradient.
Ctrl        = @Window : '.OLE_TAB_BACKGROUND'
Set_Property(Ctrl, 'OLE.AllowXPTheme', No$)
Color       = 'Vertical(Gradient(LightSteelBlue L=80, LightSteelBlue L=60), Border(LightSteelBlue))'
Set_Property(Ctrl, 'OLE.CustomPaneColor', Color)
Set_Property(Ctrl, 'OLE.FillParentBackground', Yes$)

// Create a panel with a dark blue gradient.
Ctrl        = @Window : '.OLE_TAB_PANEL'
Set_Property(Ctrl, 'OLE.AllowXPTheme', No$)
Set_Property(Ctrl, 'OLE.Height', -39)
Color       = 'Vertical(Gradient(DodgerBlue L=40, MidnightBlue L=20), Border(MidnightBlue))'
Set_Property(Ctrl, 'OLE.CustomPaneColor', Color)

// Create a pseudo-groupbox with a medium blue gradient.
Ctrl        = @Window : '.OLE_TAB_GROUP'
Set_Property(Ctrl, 'OLE.AllowXPTheme', No$)
Set_Property(Ctrl, 'OLE.Height', -52)
Color       = 'Vertical(Gradient(LightSteelBlue L=95, LightSteelBlue L=80), Border(LightSteelBlue))'
Set_Property(Ctrl, 'OLE.CustomPaneColor', Color)

// Create the buttons with a custom normal, hot, and pressed color theme.
Buttons     = 'OK,CANCEL,APPLY,RESET'
Captions    = '&OK,&Cancel,&Apply,&Reset'
For ButtonCnt = 1 to 4
    Ctrl    = @Window : '.OLE_BUTTON_' : Field(Buttons, ',', ButtonCnt)
    Caption = Field(Captions, ',', ButtonCnt)
    Set_Property(Ctrl, 'OLE.Caption', Caption)
    Background      = ''
    Background<1>   = 'Vertical(Gradient(DodgerBlue L=40, MidnightBlue L=20), Border(LightBlue))'
    Background<2>   = 'Vertical(Gradient(DodgerBlue L=60, MidnightBlue L=40), Border(White))'
    Background<3>   = 'Vertical(Gradient(DodgerBlue L=20, MidnightBlue L=40), Border(White))'
    Background<4>   = 'Vertical(Gradient(DodgerBlue L=40 G, MidnightBlue L=20 G), Border(LightBlue G))'
    Set_Property(Ctrl, 'OLE.Background', Background)
    Forecolor       = ''
    Forecolor<1>    = 'White'
    Set_Property(Ctrl, 'OLE.Forecolor', Forecolor)
    Set_Property(Ctrl, 'OLE.Font', @SVM : @SVM : 700)
Next ButtonCnt

We hope that these examples encourage you to explore different ways of adding visual interest to your applications. In order to use the CustomPaneColor and FillParentBackground properties you will need the latest SRP Core ActiveX control (v2.2.9). This is a free upgrade to all v2.x licensees and it can be downloaded with the entire SRP ActiveX control suite from here.

SRP Utilities Update, Version 1.2.2

Kevin Fournier — Wed, 07 Oct 2009 17:36:57 -0500

A customer recently discovered a glaring bug in our SRP_Hash method, which in hindsight was introduced with the release of version 1.2. In that version, we had made a change to the DLL function signature used by SRP_Encode. Much to our embarrassment, we forgot to updated SRP_Hash, which uses this same DLL function in order to conveniently encode your hashes. As a result, SRP_Hash would break to the debugger, indicating that an insufficient number of parameters was being passed to the DLL function in question. This unfortunate error on our part has been corrected in this release. We certainly apologize to anyone this may have inconvenienced.

If you are currently using version 1.2 or 1.2.1, we highly recommend upgrading. Both existing users and those that wish to try this free utility can download SRP Utilities 1.2.2 from here.

Did You Know - Using the Color Fill Property Type

Don Bakke — Sun, 27 Sep 2009 11:07:34 -0500

With the proliferation of so many 'home improvement' type television programs it is hard not to discover how important color is for both aesthetic and functional purposes. Many of the same principles apply to software design as well. However, like home owners with little experience in interior design, many OpenInsight developers struggle to create a visual experience that is both intuitive and attractive. To make matters worse, modern systems commonly incorporate desktop themes and gradients as seen in the My Computer window below:

OpenInsight's out of the box toolkit is somewhat limited in this area, making it challenging for the developer to offer these kinds of visual enhancements. One popular work-around is to create (or download) custom images and use them with PUSHBMP or BITMAP controls in very creative ways. While this helps, it doesn't provide true theme support. Quite often these images use background colors to blend with the form. This works well while the user stays in the same theme. Once this is changed the well-crafted image looks glaringly out of place. This problem was one of the primary reasons SRP began developing ActiveX controls.

Now, in addition to support for Transparency, Alpha Channel, RGB/HSL colors, System colors, MS Office colors, and HTML colors, SRP ActiveX controls give the developer custom Gradient options via the Color Fill property type. Since all of the above are fully documented in our SRP OLE Controls help document (available with our fully functional evaluation suite of ActiveX controls), this article will focus on a few examples in hopes that it will inspire you to greater visual awesomeness.

In our first example we began experimenting with ways to simulate the shiny progress bar within Vista using the SRP StatusBar. To be honest, the easiest way of accomplishing this would be to use the AllowXPTheme property since it utilizes the internal theme of Windows. However, we wanted to duplicate this look for non-Vista (i.e. primarily XP) machines. Additionally, we needed to support the custom PaneType features such as Progress Caption. Therefore we worked with the Color Fill property type to help us out. The final result was close enough for our purposes.

Internet Explorer

SRP StatusBar

The source code that we used is provided below. In this case we opted to lock down the primary colors (PaleGreen and LimeGreen) used for the progress bar. However, the border colors use the AppBackground (ABK) System color to make it somewhat theme friendly:

Ctrl = @Window : '.OLE_STATUSBAR'
Set_Property(Ctrl, 'OLE.PaneCount', 3)
Set_Property(Ctrl, 'OLE.PaneType[2]', 'Progress Normal')
PaneColorInfo   = ''
PaneColorInfo  := 'Black' : @FM
PaneColorInfo  := 'Vertical(Gradient(PaleGreen L+=20 G, PaleGreen G, 40%), Gradient(LimeGreen L+=25 G, LimeGreen L+=35 G, 60%), Border(ABK L+=10, ABK))' : @FM
PaneColorInfo  := 'White' : @FM
PaneColorInfo  := 'Vertical(Gradient(PaleGreen L+=15, PaleGreen, 40%), Gradient(LimeGreen, LimeGreen L+=25, 60%), Border(ABK L+=10, ABK))' : @FM
PaneColorInfo  := 1 : @FM
PaneColorInfo  := 1
Set_Property(Ctrl, 'OLE.PaneColors[2]', PaneColorInfo)

Our next example takes advantage of the SRP Popup control, perhaps one of the most underrated controls in our suite. Our goal was to provide the end user with a 'dialog' that provided a little bit of help when the F1 key was pressed. However, we wanted to do something that was a little different than a traditional dialog box display. This led us to the following results:

We were inspired to create a slightly enhanced 'tooltip'. Therefore, we took advantage of the ToolTip (TT) and ToolTipText (TTT) System colors for optimum theme compatibility. However, in order to provide some little visual interest we also gave it a subtle gradient. The OK button is also theme friendly as it uses the Select (S) System color:

Set_Property(@Window : '.OLE_POPUP', 'OLE.Theme', 'C')
BackgroundArray = ''
BackgroundArray := 'Vertical(Gradient(TT L=90, TT L=80, 30%), Gradient(TT L=75, TT L=80), Border(TTT, TTT, TTT, TTT))' : @FM
BackgroundArray := 'Vertical(Gradient(S L=80, S L=90), Border(TTT, TTT, TTT, TTT))' : @FM
BackgroundArray := 'Vertical(Gradient(S L=90, S L=80), Border(TTT, TTT, TTT, TTT))'
Set_Property(@Window : '.OLE_POPUP', 'OLE.Background', BackgroundArray)

Our last example combines the SRP Picture and SRP EditTable controls. The client was looking for something that was a little different than the everyday 'look and feel' window. We began with the SRP EditTable control. Each header cell has its own gradient (using the Select (S) System color) and is separated with a White gridline. However, once this look was achieved it made the rest of the window look rather plain. This led us to the idea of using the SRP Picture control as a pseudo-label. By using the same gradient scheme that we used for the SRP EditTable header cells we were able to provide the client with a uniform and theme-friendly window with a rather unique visual appearance:

Setting the SRP Picture controls was relatively easy:

Set_Property(@Window : '.OLE_PICTURE', 'OLE.BackgroundColor', 'Gradient(S L=75, S)')

Working on the SRP EditTable was a bit more complex mainly because special consideration needed to be given to the header cells that are at the far end of the control. Otherwise, the Color Fill settings are basically the same as the SRP Picture control:

Ctrl = @Window : '.OLE_EDITTABLE'
ForegroundColor = 'White'
BackgroundColor = 'Vertical(Gradient(S L=75, S)'
GridLineColor = 'S L=75'
Set_Property(Ctrl, 'OLE.HeaderColors[All; All]', ForegroundColor : @FM : BackgroundColor:', Border(None, None, White, None))')
Set_Property(Ctrl, 'OLE.HeaderColors[1; All]', ForegroundColor : @FM : BackgroundColor:', Border(None, None, None, White))')
Set_Property(Ctrl, 'OLE.HeaderColors[1; 1]', ForegroundColor : @FM : BackgroundColor:', Border(None, None, White, White))')
Set_Property(Ctrl, 'OLE.HeaderColors[':ArrayDimension<1> + 1:'; 1]', ForegroundColor : @FM : BackgroundColor:', Border(None, None, None, None))')
Set_Property(Ctrl, 'OLE.HeaderFont[All; All]', 'Tahoma' : @SVM : 9 : @SVM : 700)
Set_Property(Ctrl, 'OLE.CellGridLines[All; All]', GridLineColor : @FM : GridLineColor : @FM : GridLineColor : @FM : GridLineColor)

As of this writing, seven of the SRP ActiveX controls (Button, EditTable, Picture, Popup, StatusBar, Tab, and Tree) support the Color Fill property type in one or more ways. This gives the developer many options for 'spicing' up those ordinary windows. Please note that we are always interested to see your own works of art!