• http://www.powersoft.com/products/powerpp/testdrive.html

• http://www.pcweek.com/reviews/0610/10rad.html

The command button control can be accessed from the right-most tool button on the standard tab page of the component palette. Click on it once, then click on the form to drop it there. Move it to somewhere around the bottom right corner of the form. Move the mouse around on the form and watch the status bar located on the main Power++ window. Notice that as you move the mouse over the command button, the status bar reflects to show its name, and class - never again will you have to select an object to find out its name while coding. You won't even have to shift the focus away from the code editor if your form is visible; simply move the mouse over the desired object and continue programming with your train of thought still intact.

Now right-click on the command button and choose Properties. In Power++, double-clicking on an object displays its property sheet, as opposed to creating an event handler for that object as in Delphi, so you could have double-clicked on the command button instead. The property sheet method of setting control properties turns out to be quicker than the object inspector for a few reasons. Consider the General tab - the first one which is presented to you. Here, are all of the most commonly used properties, separated from the rest. So, for instance, if you want to set the Text property of the command button (its visual label), you would open up the command button's property sheet, and be confident that the Text property would be one of the first things you see. Try changing the Text property now to something like, 'Click Me', and hitting the 'Apply' button - notice how the command button on the form is updated to reflect the changes.

Along the same lines, what if you wanted to change the dimensions of the object? You would always know that everything you would need would be in the Size tab. One could argue that knowing to look for Width in the object inspector would be just as obvious - which is true - but it often follows that you would then want to change the height of the object, and 'H' is a long way from 'W'... A more logical approach would be to group together all dimension-related controls, and this is exactly what the Size tab is for. But now that you are looking at the Size tab page, what are these Resize Percentages? Therein lies another nice feature of the property sheet. Right-click where it says Left Percentage, and choose 'What's This'. Rather than bothering with the online help, which would be overkill just to find out what a particular property does, the context help in property sheets will be your best friend in Power++. Now that you have read what the Left Percentage property does, set the Left Percentage to a value of '100', and click OK to apply the changes and close the property sheet.

Now run the program by choosing Run from the Run menu, or by clicking the Run toolbar button which depicts a green person running, superimposed over a file. (Note that the first build is always slower than subsequent builds in Power++. Still, don't expect it ever to get quite up to the compiling speed of Delphi - Pascal and C++ are very different languages, and a C++ compiler has much more work to do than a Pascal compiler.) Now that your program is running, try resizing it. Notice how the command button's right side remains glued to its position relative to the right side of the form - and without writing any code! From this, you can imagine how fooling around with the different Resize Percentages properties, and different values for them can create almost any effect you want. Take a deep breath and repeat: "I will never write another resize event handler again."

Even in the case of events, you usually don't need to touch the Object Inspector (which we still have not looked at, but will shortly). For instance, 99% of the time you wish to write an event handler for a command button, it is one which is associated with the Click event for that button. Let's write a simple Click event handler for our 'Click Me' button that changes the titlebar text of the form, as well the text label for our command button that is to be clicked. Right-click on the command button. The first item in the popup menu is Events which leads to a sub-menu which lists the most common events for that particular control - in the case of a command button, only Click. Ignore the More choice for now, and choose the Click item. Finally we are brought to the code editor of Power++.

Some notes before we go on. You will notice that the event handler created is of the form:
    WBool FunctionName( WObject * source, WEventData * event )
In fact, all event handlers are of this form, where source is a pointer to the object that called the event (all visual objects in Power++ are descendants of WObject), and event is a pointer to a structure which contains information relevant to the event. event is a pointer to an object of type WEventData, or of some type derived from WEventData (for example, in a MouseMove event, the event parameter would be of type WMouseEventData, and would contain such useful information as the position of the mouse when the event was fired). This is important, because it means you can assign any type of event to the same event handler if it suits your needs in your program. You will also notice that the event handler returns a boolean result. Power++ has a powerful feature known as chained event handlers which we will not go into detail about here. But assume that there is a default Click event assigned to your button, even before you assign one yourself - this event takes care of default background nitty gritty click stuff. When you assign your own Click event handler to the button, rather than replacing the existing one, it is chained on top of it and executes before it when the button is clicked. If your Click handler returns FALSE (as it will 90% of the time), the default handler will execute after yours to finish the job. If your even handler returns TRUE (not usually what you want), default (and other) event handlers that yours is chained on top of are ignored, and you are saying, "I have done everything to handle this event, don't do anything else."

Now add two lines of code (in bold below) to the event handler created for you, so that it looks something like this (don't forget that C++ is case-sensitive, so type the lines exactly as they are here):

WBool Form1::cb_1_Click(
    WObject *           source,
    WEventData *        event )
{
    SetText( "New Title!" );        // Set the titlebar text
    cb_1->SetText( "Clicked!" );    // Set the button's text label
    
    return FALSE;
} Run the program just to see that it does what the comments say it will when you click the button. To put things into perspective, if this were Delphi the lines might have looked something like this:
    Text := "New Title!";
    cb_1.Text := "Clicked!";
As opposed to Delphi's way of accessing properties as sort of variables, Power++ uses Get and Set methods for accessing an object's properties. This was done because C++ lacks an equivalent to Object Pascal's published properties. Getting used to Power++'s way of handling properties, is simply a matter of using it, but aside from this, there are also some interesting advantages to using methods to access properties. Power++ takes advantage of the ability to overload functions in C++. For example, if you have a simple status bar named StatusBar, with only one text area, you could use one form of the Text property's Get and Set methods, as in:

WString oldStatus = StatusBar->GetText(); // Get the old status text and stick
                                          //     it in a string variable 'oldStatus'
StatusBar->SetText( "New Status Text" );  // Set some new status bar text But imagine that your status bar was divided into 3 parts; in this case you could use another form of the Text property's Get and Set methods, like this:

WString status = StatusBar->GetText( 1 ); // Get the status text from the *second* part
                                          //     of the status bar, and stick it in a
                                          //     string variable 'status'
StatusBar->SetText( 2, "Third Part!" );   // Set the status text of the *third* part of
                                          //     of the status bar

What if you wanted to create an event handler other than Click for the command button? Finally we will need to use the Object Inspector. Right-click on your command button. Notice that Click is checked off in the Events sub-menu indicating that you have associated a handler with that event. All events which you associate with a handler at design time will appear on this list with a check next to them (even ones that aren't here before you associate a handler with them), which gives you a quick way to check if a particular event of an object is being handled, and also gives you a quick way to access that event handler (by clicking on it in this list). Now click on More to bring up the Object Inspector with the full list of possible events for this button. If you are thinking to yourself, "err... this is a big list," I don't blame you. Power++ gives you a lot of power, providing you with direct access to almost any event you could want. Some event which might require using obscure windows messages in Delphi, would probably be directly supported in Power++.

Go down the list until you find the LeftButtonDown event (you can hit the 'L' key twice to get there). Click on it once so that it is selected, and then click on the '...' button to create an event handler for it. Add the following lines of code, in the same way you did for the Click event:

WBool Form1::cb_1_LeftButtonDown(
    WObject *           source,
    WMouseEventData *   event )
{
    SetText( "Down Title!" );    // Set the titlebar text
    cb_1->SetText( "Down!" );    // Set the button's text label
    
    return FALSE;
} Run the program, click and hold down on the button, and then release the mouse button. What do you think would happen if we changed the last line of our LeftButtonDown event handler to 'return TRUE;' instead of 'return FALSE;'? Try it out and see the expected effect. Note that if you double-click, you will be able to get the Click event to fire on the second click of the double-click. To stop that as well, you would need to return TRUE in a handled LeftButtonDouble event (which you can try if you wish). Now close the code editor and the Object Inspector. What if you made a mistake in the code of your LeftButtonDown event handler? Simply right-click on the Command Button, and find that the desired event is now located, with a check mark beside it, in the Events sub-menu of the button's popup menu. You can click there if you wish to edit it.

There is a situation in which the Object Inspector is easier to use than the property sheet, which is when you want to set a property of multiple objects to the same value - for instance, setting all Text Boxes so that they have the same value for their Left property. But there is a much easier and more visual way to do this. Select all of the text boxes you have placed on the form, and right-click on the one whose current left position looks nice. Form the Align sub-menu, choose the first item and watch the magic. Now right-click on one of the Text Boxes again, and choose the second to last item in the Align sub-menu (you will only be able to see this nice effect if some of the Text Boxes are of different widths). You can align the right side of the Text Boxes by choosing the second item from the Align sub-menu. Now again align the left edges of the Text Boxes. Right-click on the Text Box whose Width property you like. From the Same Size sub-menu, choose the second item. Now wasn't that fun? :)

View / Objects shows the hierarchy of objects used in your program. You can also change an object's properties here, delete it, or edit one of its associated events. View / Files lets you inspect the files associated with your project, delete the ones not needed, and add new ones. View / Debug Log allows you to take advantage of Power++'s advanced memory usage checks and Validity Checks. In the debug log window, choose Options from the View menu to set these up. View / Error Log brings up a log of all the errors in your project. Power++ has a great way of displaying coding errors - it actually inserts the error message into the code itself, and erases it when the problem is fixed. Try it yourself - in an event handler, write some nonsense code, and try to run the program. Apart from these in-line error messages, the Error Log keeps a list of all the errors and warnings in a more traditional fashion, and lets you link to their position in the code, by double-clicking on the message. You can get help on the message by right-clicking on it (in either the Error Log, or directly in the editor), and choosing Help.

Choose Resources from the View menu. Here you can add bitmap, cursor, icon, string, and user defined resources, all of which can then be used from within your program. You can also edit the version resource, which is the information about your program that is accessible to users from the Version tab when they right-click on your program's EXE from explorer, and choose Properties. Click on Icons in the left pane. You can add as many icon resources as you wish to your project. Double-click on Form1 to bring up its property sheet. You will notice the Icon property at the bottom of the General tab. If you drop down the associated combo box, you will see the default ICON_1 from the Resource View listed there - choose it and click OK. If you had added other icons to the Icons Resource, they would be listed here as well. You could use the same icon on as many forms as you like without fear of increasing program size, since the only copy of the icon is stored in the resources.

Now choose Targets from the View menu. Here you can specify which target you want to build, by selecting it in the drop-down combo box. A green check mark next to each item indicates that its Build Status is up to date. You can also change all the options for the currently selected target. For example, right-click on the project name (the root item in the treeview), and choose Properties. Here you can change general project properties; for instance, the Executable Size tab page lets you specify weather or not to use the runtime DLL. Close this property sheet, and bring up the property sheet for applic.wcx. You can change to the Optimization tab and take a look at all the optimizations that you have power over.

If you have a background C programming, the Getting Started section of the Power++ help system may be all you need to learn the essentials of C++ and start programming real applications in Power++. If, however, you have no experience in either C or C++, it is recommended that you read a good book on the topic. A great tutorial available on the web for learning C++ is by Coronado Enterprises. The tutorial assumes you are already familiar with C programming. If you are not, another tutorial is available, from the same source, on C programming, which you can read as a primer to the C++ tutorial. Both of these books are available for reading on-line here:

• Coronado Enterprises Tutorials

Even if you are not already familiar with C++, you can still do some real programming in Power++ by taking a look at some of the many example programs that come along with Power++, and getting the jist of things from them. In fact it is recommended that you do this in any case, since learning by example is often the best way to grasp the idea behind something. And, of course, the Power++ Component Library Reference is the ultimate reference to all the properties, methods, and events for the different components in Power++ - press the F1 key while a component is selected to bring up its help topic in the reference. Power++ has a lot to offer the power programmer and database developer. Give it a try, and you might not want to ever leave it.