posted 06-30-2008 05:18 PM         

I could list a lot of things here, but I will discuss just a few things easily overlooked.

(1) Advanced GUI features for building advanced GUI's.

What I mean by this is that there are a number of more advanced tasks that can be done with Windows applications, that are simply beyond the average PB programmer, even those experienced with the Windows API.

Let's look at the Listview control for example.

Experienced API programmers can easily create and populate a Listview control.

But what about some of the more complex tasks done with a Listview ?

EZGUI provides simple commands for such things as:

- Sorting a Listview by column
- Sorting a Listview by multiple columns combined
- Searching a Listview by a single column (subitem)
- Searching a listview by multiple columns combined

A very complex task is implimenting drag and drop in a Listview. EZGUI allows you to not only drag/drop an item within a listview, but also to drag/drop an item to another control or even another Form (top level window). A very complex part of such drag/drop within the control is autoscrolling. When you drag and item to the top (or bottom) of the list, it will autoscroll the list for you.

This drag and drop engine for the Listview (and Treeview) is beyond the average PB'ers to write themselves, but yet EZGUI makes it so simple even a beginner can use it.

This is not all there is.

How about working with the RichEdit control ?

EZGUI provides the ability to read/write both ascii text or RichText (RTF) from/to the control. It provides hyperlinking support, so you can add hyperlinks to the text (ie. web urls) and generate an event when the link is clicked. There is also the ability to print the actual Richtext to either a printer or even a Canvas control.

If you have ever worked with the RichEdit control using the Windows API, you will know that the tasks just mentioned are not easy to learn how to do.

When you examine the list of controls supported by EZGUI, you don't immediately appreciate the scope of what it can do. Many controls have advanced features not used by the average API programmer, since they require a bit more complex API's and notification message processing.

For example, EZGUI allows you to convert a normal Listbox control into a Drag Listbox by simply using one property when creating the control. EZGUI handles all the complex stuff for you.

Two less often used controls, the Pager control and Rebar control are easily used with EZGUI. You simply create either a Pager Form or Rebar form (for bands) on the controls and EZGUI handles the rest. Just add any controls you like to these forms and you have a complex GUI.

EZGUI is not just some wrapper over hundreds of API's (or messages). It is an engine. The features added were done by task, not by choosing an API. First a task was chosen that needed to be implimented (ie. I need to sort a listview by column). Then all the necessary steps were implimented to accomplish the task. Often this means processing messages internally, such as WM_NOTIFY notification messages. Events were added to match the needs of the task.

It is the low level complexity of this engine which is often not fully appreciated. The reason EZGUI could impliment features not found in other Visual Design tools for PowerBasic, is that it is an engine which handles many mundane tasks for you in the background, so the task can be accomplished.

The complexity of this engine is far beyond any other GUI tool for Powerbasic. No other GUI tool currently has the feature set to build a Visual Designer! EZGUI has its own engines for implimenting all the features you need to build your own WYSIWYG application, like a Visual Designer.

EZGUI's Thread engine is the most advanced Threading tool available for use with Powerbasic. EZGUI went far beyond simply adding Thread creation commands. A lot of research was done into how Threads should be used in a GUI application and the best way to impliment them. For example, all GUI code should be in the main thread (primary thread of the application). EZGUI uses critical sections to control how threads communicate with the primary thread, so you can get a unique thread event in the primary thread and do all your GUI code there. EZGUI provides easy to use critical section commands so you can syncronize the threads when accessing global data or routines.

EZGUI allows customization far beyond any other GUI tool. For example, it is relatively easy to add support for the Common Dialogs, but what if you want to custom these Dialogs ? EZGUI creates all the necessary hooks internally so it can process events for the dialogs and allow you to customize them beyond what is standard for the dialog. You can resize the dialog, center it, move it, convert the buttons to ownerdraw and change the colors. You can process some events from the controls in the dialog itself. You can expand the dialog and add an EZGUI form on it with your own controls. This is not easily done by the average API programmer. EZGUI handles all the hard stuff for you, so you can concentrate on how the dialog will look and act.

EZGUI goes beyond the standard stuff.

For example, not only are ToolTips supported, but EZGUI allows easy customization of all sorts of Tooltips (form tooltips and tooltips created by common controls). You can customize their size, color, shape and even display multiple lines of text. You can add up a 1024 characters to a form tooltip.

When designed the EZGUI engine, I didn't just impliment a common task, but I looked for ways to expand the task to its limits.

It is this difference that makes EZGUI unique. It allows you to build applications far beyond what you may have ever dreamed of. Even some programmers who made the jump straight from DOS Basic to Windows now can write applications that have features that even many experienced API programmers couldn't write.

(2) Reliability

It should be obvious that the more complex an application becomes (especially the GUI), the greater likelyhood of there being bugs. As a specific API task becomes more complex to impliment, the greater likelyhood of producing bugs occurs.

The advantage of EZGUI is its being an engine. It is not just a lot of generated code by a Designer. It is an engine built upon reusable code (modular) which has been very well tested. One a modular routine in the engine has been tested well, then every time you use it, you have the benefit of reliable code.

While it is true no software can be guaranteed bug free, EZGUI has the advantage of being as close as you can get to that. It has a proven track record of being very reliable and this greatly effects the quality of your software.

No matter how much you may like a Visual Design environment or how fast it may be for development, the reliability of the code generated or used (GUI engine) is what really matters. The best looking software can be ruined by hard to find bugs.

With EZGUI, reliability is what came first. That was a key goal in its development. The GUI engine had to not only work, but it had to work right.

EZGUI also has the advantage of its engine being designed to work on as many operating systems as possible, from Windows 95 to Vista. This backward compatibility benefits the developer, because you don't get surprises when your application works fine on your development PC (ie. XP) and you find later it won't work right on another (ie. 98/ME).

EZGUI polls the operating system and uses different API's for different operating systems. If an API only exists on a later OS, EZGUI loads the OS DLL dynamically and polls the DLL to see if the API exists. in the worse case secenario, the few features which require a later OS, which simply not do anything, rather than crash the app with Windows saying a DLL function is missing.

Some programming environments tend to cater to the latest and newest operating system. This is not realistic, since the users of the software may have varied systems. EZGUI allows you to build advanced GUI's which can run on the largest number of PC's.

If you write commercial software and you want to have a reliable application which will run on as many PC's as possible, then seriously consider EZGUI 4.0 Pro.