News: SUPER SPECIAL OFFER: Upgrade to EZGUI 5.0 Pro for only $39 ! (until 04/30/2015)
New users special offer:  EZGUI 5.0 for only $99 (until 04/30/2015)

Check out our online Video Tutorials !

TO REGISTER on Forum, contact tech support:
Pages: [1]   Go Down
Author Topic: Benefits of using EZGUI 5.0 Professional  (Read 6736 times)
0 Members and 1 Guest are viewing this topic.
Chris Boss
Hero Member
Posts: 2754

View Profile
« on: July 02, 2012, 12:44:35 PM »

Part 1:

The decision to purchase a tool like EZGUI requires some real thought into the benefits it offers. The price ($249) may turn some off at first, but as many of my customers have told me, it is worth it.

If you are looking for a better development environment, more features , better quality and faster development speed, then please seriously examine the following:

(1) Reliability

One of the key goals in the development of EZGUI has been the need for reliability. Especially if you are developing commercial applications, you can't afford to have your software suffer because of poor code.

This is one of the reasons, I chose to use a runtime (DLL), instead of generating 100% code. I didn't want anything to break, when programmers used EZGUI. They would depend upon it and could ill afford to have their applications break, because something was wrong with EZGUI or code generation.

Note: A SLL version is in development !

EZGUI is now in its 5th generation and the core runtime routines are tried and true. My customers depend upon them. Now of course no one can say their software is 100% bug free. I would never say that. But I feel (and I think my customers would agree) that EZGUI 5.0 is as good as it gets as far as reliability.

Why ?

There are a number of reasons, but I will mention a few here.

First, is my view of debugging software. Debugging is an art form, IMO. It is easy to lack patience when debugging software and to not put enough time into it. If you ask my customers (when bugs have been reported), I at times may spend days trying to figure out what is wrong and to find a solution. No matter how long it takes, I try to do it, so I can make sure my customers have confidence in EZGUI.

Another aspect of debugging something as complex as EZGUI is the need to research the Windows API thoroughly. I have found it critical, that I fully understand the proper way to use the API. Again this takes time and patience. I never use an API call, unless I fully understand how it works first. I never just copy others code from what is available on the Internet. I want to understand how it works and why. I want to understand the underlying API's involved.

There have been times, my customers have requested a feature and I simply reply that I can't add it yet, since I do not fully understand or grasp the concepts or API's involved enough to add it. Nothing goes into EZGUI, before I grasp the concept and methods involved to a reasonable degree.

I don't expect potential customers to take my word for it. I prefer to let my customers speak. If you have any interest in EZGUI feel free to post your questions on this forum and let my customers give you honest feedback.

Another aspect of reliability, has to do with the problems associated with multiplatform development. EZGUI was designed for developing applications that will run on OS's from Win95 to Windows 7 (and Windows 8 too). One of the problems with some development tools today (and this includes many non-PowerBasic programming languages/tools) is that they are written for the "bleeding edge" of operating systems. Just take a look at software tools you purchase (or even end user software) at the "requirements" needed to run the software. Not only do you often see only later OS's being supported, but at times you will see references to "service pack versions". This dependence upon only the latest OS or service pack, makes it very uncertain whether you can develop applications for a variety of platforms.

EZGUI was designed so it can run on as old a platform as possible and yet still take advantage of later OS features.

For example, EZGUI's graphic engine, including the new Sprite engine, should work even on Windows 95 without any special OS runtimes, like DirectX or GDI+. EZGUI actually pushes the limits of features in Windows that have been around since Windows 95, but are not often used. One example is OwnerDraw. You can customize the look and feel of controls far beyond the basics supported by the OS. EZGUI 5.0 comes with full support, even in its Designer for 3D colored buttons in 4 different styles (using the new plugins feature). EZGUI 5.0 supports things like non-rectangular Forms using bitmap images and regions. There are many advanced features, which still only requires a minimum of Windows 95. Even EZGUI 5.0's new OpenGL 3D control works on multiple operating systems. I have tested it on Windows 8 and amazingly it even ran quite well (albeit a little slow) on an old Windows 95 computer.

Now for those features which do require later versions of Windows, EZGUI takes a safe route. Instead of making the runtimes dependent upon later OS API's, EZGUI instead will poll the OS to see if the features are available and then will dynamically load any needed API calls. What this means is that your applications won't be limited to later versions of Windows. You can still run them on earliers versions, but a few features simply may not be available (the few features in this catagory often are more eye candy than anything else and may not be critical to the apps functionality).

The point is that EZGUI goes to great lengths to give you as advanced features as possible, while still only requiring as minimal as possible the requirements of the OS.

A good example is EZGUI's sprite engine. Just imagine being able to have sprites which can be alphablended and anti-aliased on as old an OS as Win95. Now of course the speed of a CPU may limit how much can be done when working with heavy graphics.

One may ask, why support older OS's ?

While it is true that many people have either Windows 7 or Vista, there are also many computers still used today that run older OS's. In business these older computers are often relegated to lesser tasks, but they many times are still used. Imagine the potential for your software if it can run a even older computers, while still offering advanced features and a small footprint. Surprisingly the legacy Windows XP is still used by a significant number of businesses today. To be able to write software which runs just as well on Windows XP as it does on Windows 7 (or Cool is extremely valuable.

Even if you aren't concerned about older OS's, you still may be concerned about all the changes between service packs on current OS's and whether it will break your software. Since EZGUI attempts to use only API's which have changed little from Windows 95 to 7, it is less likely to be effected by service pack changes.

The goal has been, "aim for as a consistant as possible reliability on as many Windows platforms as is possible" (32 bit). There aren't many programming tools today that aim for that. I recently downloaded a free express version of a MS product, only to find that it would not run on my PC, since it was only service pack 1 (XP Home). Another well known compiler maker, also had free versions of some of its compilers and they to would not run on my system. I have a 2.5 ghz PC, 256 meg ram, 128 meg video card, with XP Home and yet I can't run a variety of programming software. While not the bleeding edge, it surely is not old or obsolete.

EZGUI offers developers the ability to build powerful, feature rich software, which will run on as many systems as possible.

To be continued ...

Chris Boss
Hero Member
Posts: 2754

View Profile
« Reply #1 on: July 02, 2012, 12:58:04 PM »

 Part 2: Ease of use and Rapid Development

EZGUI was designed to make programming complex Windows applications as easy as is possible. This does not mean that it lacks power and is only for beginners.

Everyone is familiar with the old saying "why reinvent the wheel".

You might say that EZGUI is similiar. EZGUI provides a rich command set which allows you to concentrate on the task at hand, rather than wasting time on the complexities of the Windows API.

For example, the command:


clears the data or items from the Listbox , ComboBox , Listview , Treeview, Tab control , Turtle Graphic control and the Canvas control.

One command which handles a common yet simple task, clears the data from the control. Yet each control type has its own unique way of doing this via the API. EZGUI goes farther, by giving you one command for all of the above controls. The command tests the control to see what type (class) it is and then uses the appropriate API to clear the control of its data or image.

This one command is like 7 commands in one!

Yet the purpose for it is simple and its implimentation is also simple.

This demonstrates the basic concept of the EZGUI engine. Why bog the programmer down with all the dirty details, when he simply wants to do a given task ?

This means the EZGUI command set is not only simple to use, but at times it actually handles multiple control types per each command, so the command set is actually larger than you would think. It would probably take a similiar tools library of wrapper functions a 1000 or more functions to do what EZGUI does.

For example, EZGUI 5.0 has two commands, EZ_SetAttr and EZ_GetAttr (which sets/gets attributes of controls) which alone encapsulates over 150 API messages and handles many different controls.

The command set alone gives programmers the necessary tools to build very complex applications in as short of time possible.

EZGUI is also very high level, when it needs to be. At first glance one may have the impression that EZGUI's runtime is simply a large number of simple wrappers over relatively simple API calls. This is not the case. There is a significant number of very high level commands or engines in EZGUI.

For example, the EZ_ToolBar command which creates and populates a complete toolbar control (defines bitmap, buttons, properties for buttons, etc.) uses nearly 400 lines of code in it. Yet this one high level command only requires one line of code in your applications. Imagine if your application has dozens of toolbars in it, the savings in coding.

EZGUI also contains a number of very high level engines. The Visual Designer Drag and Drop engine alone contains many hundreds of lines of code. This engine impliments drag and drop features which would be very difficult to do using the API directly. EZGUI has a number of engines built in, such as a subclass engine (makes subclassing easy and safe), drag/drop designer engine, event engine (ie. EZGUI's WM_NOTIFY processing code is over 600 lines of code and handles the most common WM_NOTIFY notification messages and converts them to easy to handle events, including customdraw).

EZGUI 5.0 has a ownerdraw engine which makes customizing controls very easy to do. This makes it easy for EZGUI to impliment 2D and 3D colored button controls, fancy ownerdraw menus, listboxes or comboboxes and even to customize the listview control.

EZGUI 5.0 has a Thread engine which not only makes writing thread code much easier, but also much saver. EZGUI handles all the difficult stuff like syncronization using critical sections. It makes it easy to pass events between worker threads and the main (primary) GUI thread.

Basically, EZGUI offers so many high level features, you would be hard pressed to find another tool that handles so many different tasks.

EZGUI was developed with the idea of tasks and not API's. I didn't just pick API calls and say, let's make a wrapper for this. I asked the question "what tasks would a programmer need to do" and then I wrote high level commands to do the task. Some tasks took only a few lines of code, while others took hundreds of lines of code. Some tasks required hooks into the internal window procedure engine for all forms, to work, or requires subclassing of a control first (or even its children) to process everything necessary to accomplish the task.

The best example of such a high level command is the new EZ_StartDrag command.

This command alone has over 550 lines of code in it (maybe more) and it impliments the complex task of creating and moving a drag icon for both the listview and treeview controls. This is a very complex task, which requires subclassing the control (internally) and creating or using imagelists. Yet with one line of code you can impliment the drag icons for these controls.

There are many more examples of the high level nature of EZGUI. This is why I usually refer to EZGUI as an engine, rather than simply a library of code. One could even consider EZGUI as a UI Framework since it does so much.

Also I haven't even mentioned yet a number of very high level features in EZGUI like its Canvas control, Sprite Engine with anti-aliasing and alphablending, the print engine, the graphics engine and more. The feature set is very extensive. EZGUI 5.0's new OpenGL based glCanvas control comes with its own 3D scripting language to make using OpenGL as easy as possible. It supports the STL 3D model file format for fast loading of huge 3D models for amazing detail. On an inexpensive 3D enabled video card, I was able to animate an STL model with 500,000 (1/2 million) polygons easily with a frame rate of 10 fps and that was not using the optimize feature of the engine, which can significantly speed things up by using large vector arrays to pass 3D models.

All this alone should speed up development time when building applications, but there is much more.

EZGUI 5.0 comes with the most advanced visual designer ever provided in the EZGUI line of software. The 1.0, 2.0 and 3.0 Visual Designers don't even come close to the advanced features of the 5.0 Designer and EZGUI 5.0 has added significant improvements compared to the 4.0 Designer.

EZGUI users can build applications in a full RAD environment. You can move seemlessly between the Visual Designer and your favorite code editor (works with the PB IDE and JellyFish) back and forth. The Designer will update your source code to match any changes in the Forms in your project. Using the new Smart or Intellegent Parser, the Designer literally rewrites your code for you and automatically runs your code editor of choice. You can build complete applications with dozens of forms as one complete project.

The Designer also has many ways to customize your applications code generation, via its project properties dialog. Change aspects of your projects code generation properties and you will get an application more suited to your style of coding. If there are not enough options for your coding style, then you can even write your own custom "code plugin" which can modify the code after the Designer generates it and before your code editor gets it.

The EZGUI Visual Designer is not like most programming RAD environments. It wasn't designed to emulate other programming environments, like VB. It was designed to optimize using the EZGUI runtime engine and its features. The Designer actually looks quite simple at first glance, but in reality it supports many advanced features.

One of my favorites, is the ability to hide the toolbar, statusbar, captionbar and menus of the designer in a "Full Screen" mode. This allows you to work unfettered with large forms that take up the whole screen.

EZGUI supports a layering feature, not found in most RAD tools. Similiar to graphics programs which can put objects on different layers, the EZGUI Designer can put controls on different layers. These layers can be shown or hidden when needed (also via code in your app). This makes implimenting Tab controls or those wizard style dialogs very easy. Layers are not tied to any one parent control (like a Tab control). They are independent and associated with the parent form.

The Visual Designer also supports all the controls supported by the EZGUI runtime (all the standard controls and most of the common controls). It also supports most of EZGUI's custom controls (Canvas, Turtle, Shape/HotSpot, masked edit, MCI) and even supports third party controls (which are in DLL form and support standard API's).

Unlike RAD tools that generate a lot of code and then you are left on your own, EZGUI provides a Visual Designer front end for fast development, a powerful code generator and smart parser to generate the GUI code and then a powerful GUI engine with a rich command set to handle all the tasks you need to build power and complex applications.

If your time is valuable and you need a fast development environment, EZGUI offers many exciting features that will make software development productive and fast.

If you have specific questions about EZGUI, feel free to post them on this forum, or email me at:

To be continued ...

« Last Edit: July 30, 2012, 03:39:07 PM by Chris Boss » Logged
Chris Boss
Hero Member
Posts: 2754

View Profile
« Reply #2 on: July 30, 2012, 03:57:21 PM »

Part 3: Advanced Features

The feature set of EZGUI 5.0 is very extensive, but here I will list just a few of the powerful features found in EZGUI 5.0 that help you develop state of the art applications.

First let's look at controls.

Not only does EZGUI support all the Standard controls, but is also supports most of the Common Controls.

Working with the common controls using the API is where things start to get a little bit tricky. EZGUI provides an extensive command set to support each control.

For example, when working with the Listview control, EZGUI provides commands to search a listview, to sort a listview, to customize it using ownerdraw or customdraw. It supports working with ImageLists which are very important for controls like the Listview.

The RichEdit control is very powerful, if one knows how to handle the more complex features of it. EZGUI provides commands (and events) to handle things like filling the control (or reading it) with huge RTF text strings (in the megabytes), setting text fonts, tab positions, paragraph settings and even hyperlinks. How about pasting RTF text from the clipboard into the RichEdit control.

Two less often used common controls supported in EZGUI 5.0 are the Rebar and Pager controls. While the controls seem simple at first glance, they may be difficult to impliment using the API. EZGUI 5.0 provides a feature where the child of a Rebar or Pager control is not other controls, but a Form. This way you can embed a form into a Rebar or Pager and then treat it like any other form, by putting as many controls on it as you like. This makes handling control events much easier, since the child controls always have a parent form, rather than a Rebar or Pager for a parent.

EZGUI 5.0 supports the Tab control, ToolBar, ProgressBar, TrackBar, StatusBar, UpDown control, Date Time control, Calendar control, Listview, Treeview, Rebar and Pager controls.

EZGUI also comes with a number of custom controls.

These are controls I have written, rather than built in ones found in Windows. This actually gives you a number of extra components, not found in some other Design environments. EZGUI 5.0 comes with a Canvas control, Turtle Graphics control, MCI control, Masked Edit control, Drag Handle control, Shape/Hot Spot control, Files Listbox and Properties Listbox control. New to EZGUI 5.0 is the glCanvas control which is based on OpenGL and it gives you an extensive 3D scripting language. There is no need to learn the OpenGL API just to do 3D. It also supports an industry standard STL 3D model file format. STL is not a gaming format. Gaming model formats often concentrate in low polygon models, with texture maps and 3D shaders to give the impression of detail. STL concentrates on high polygon counts where the detail comes from the high polygon count, rather the fake detail from texture maps. I have loaded the glCanvas control with models with over a half million polygons, up to over 900,000 polygons (triangles). The detail with such high polygon counts is amazing. STL is very useful for business style applications, rather than for games.

The regular Canvas control is more than just a control to display a Bitmap. The graphics engine allows you to draw all sorts of things, from text, shapes, bitmaps, icons, imagelists, Gradients (and 3D Gradients), Polygons and PolyBeziers. The Canvas control supports double buffers, so you can draw on two different buffers and to copy images from one buffer to the other. It also supports DIB Sections. A DIB Section is where the Canvas control allows you to define the color format of the buffer (16, 24 or 32 bit) and gives you direct access to the bitmap pixel data. This allows high speed access to pixels. This is much faster than the Get Bits/Set Bits technique. That method requires copying the pixels (bits) to a memory string first, then modify them and then copy them back again. EZGUI gives you direct access to the DIB Sections pixel data, so you never have to move them. You modify them directly. In programs which modify large blocks of pixels, EZGUI's direct access would be significantly faster. You could easily impliment an image filter for the Canvas, like converting to GrayScale. You can read and write the pixel data using pointers. EZGUI 5.0 also introduces many new graphic commands for things like 22 built in image effects (for drawing bitmaps), 360 degree image rotation with alphablending and transparency.

Now if this wasn't enough, EZGUI 5.0 provides a new Sprite Engine. Sprites are image buffers which are drawn on top of the Canvas control, which provide for transparent pixels. This allows you overlay the Sprites onto a fixed background image. They have zorder, can be moved, shown, hidden, flipped, animated (multiple frames) and even AntiAliased. Sprites also support AlphaBlending, which means they can be semi transparent (or translucent). It's like looking through a colored piece of glass. The sprite engine even works on Windows 95! No DirectX, no GDI+, just pure GDI calls. While it may not compare to DirectX's speed, it is quite fast. It can be used for all sorts of business applications or to create animated controls of your own design.

All of this is built into EZGUI 5.0!

You don't have to purchase a separate graphics engine, since EZGUI comes with one.

The Canvas control and Sprite engine alone could be sold for $100 or more. Other Visual Designer environments don't come with such a complete graphics engine, so you can't compare the price of other tools with EZGUI, since it comes with so many other components. Imagine what you would pay for a separate 3D engine as well.

As noted previously, EZGUI is very high level and it offers many very high level features, which only require a few lines of code to impliment in your applications. The Canvas control and Sprite engine is one example.

The Turtle Graphics engine is another. While the Canvas control is raster based, the Turtle Graphics control is vector based. You draw images by defining a string of turtle graphic commands (something akin to the old DOS Draw command). You can define an image using vector based turtle graphic strings and if you resize the image, it is scaled, since it is a vector based image. This is useful for building CAD like applications.

How about a Properties Listbox control ?

EZGUI's properties listbox control allows you add some advanced GUI features and it is built into the main runtime.

Many features which are often a pain to do using the API, are simple with EZGUI. For example, EZGUI 5.0 has a new simplified Thread Engine which not only allows you to create worker threads, but it has built in features to syncronize the worker threads with the main GUI thread. It uses Critical Sections internally to syncronize the sending of events between threads and also allows you to define your own critical sections for syncronizing things like the accessing of global variables between threads.

EZGUI provides commands for defining Tray Icons and Tray Icon Popup Menus, accessing the registry, accessing the clipboard with Text, RTF text and Bitmaps.

EZGUI's graphic engine provides features for drawing into any window DC directly or during ownerdraw events. EZGUI handles the cleanup for all graphics, such deleting bitmaps, brushes, fonts, etc. which your program creates, when the application terminates. You don't have to worry about all the possible resource leaks you may generate in code. EZGUI tracks such things for you and does its own house cleaning.

How about using regions to create non-rectangular forms or controls ?

EZGUI provides a simple command set that makes this easy.

How about those fancy ownerdraw menus or drop down lists (comboboxes) found in many applications today ? EZGUI 5.0 provides the Simplified OwnerDraw command set which makes this easier than ever.

The thing to remember about EZGUI's command set, is High Level and Ease of Use. Many high level commands are provided which makes difficult tasks as easy as is possible. Once you get up to speed using EZGUI's advanced features, you will be able to write applications that once were left to advanced API programmers. If you can program using DOS Basic, you can write Windows applications using EZGUI 5.0 and with advanced features at that.

Have you stayed with the Console compiler, because you just can't make the move to GUI programming ? Then give EZGUI 5.0 a try and you will be surprised at what you can develop. You can even code GUI applications without using the Visual Designer, because it is so easy to code with. EZGUI's GUI command set is as simple to use as many DOS commands. It even uses a character based coordinate system like DOS Basic, but unlike DOS Basic, the coordinates can be floating point, which is how EZGUI allows you to define accurately down to the pixel level. EZGUI's character units are even scalable like dilaog units, but more powerful, because you still have pixel level accuracy. Some EZGUI users who write commercial quality applications hand code their entire application, rather than use a visual designer. So if you prefer to hand code, rather than use a visual designer, then EZGUI would be a good choice for you.

EZGUI 5.0 also introduces a number of very important new features such as the new autosize engine. EZGUI's autosize engine is even customizable, when the autosize properties don't offer enough choices for you. You can even test the autosizing of forms in the visual designer in test mode, even bore generating a single line of code (no need to compile either). There is also the new support for multi-monitor systems. The new private timers (each control can have its own private timer) is a favorite of some EZGUI users.

EZGUI also provides its own Threading engine which was specifically designed for GUI applications. I did a good bit of research into how best to use threads and EZGUI was specifically designed for communication between worker threads (for non-UI tasks) and the primary GUI thread. From this research I learned it is important to separate non-UI tasks from UI tasks and to always leave the UI tasks to the primary thread. EZGUI was designed for better integration between worker threads and the main UI thread. A lot of thought went into how best to handle threads in an EZGUI application. With PowerBasic it may be easy to create threads, but this does not mean that it is easy to proper integrate multiple threads and the primary thread in an application with proper syncronization. EZGUI handles all of this for you, as long as you follow a few simple rules and use EZGUI's threading model the way is was intended.

« Last Edit: July 30, 2012, 04:06:24 PM by Chris Boss » Logged
Chris Boss
Hero Member
Posts: 2754

View Profile
« Reply #3 on: July 30, 2012, 05:00:47 PM »

Part 4: Graphics, Graphics, Graphics !

EZGUI 5.0's graphic engine is quite unique.

While PowerBasic offers some great new graphic features and there are other third party graphic tools available, EZGUI's graphic engine offers some great features that can really enhance your applications.

Let me explain in a little more detail about what makes EZGUI graphic engine so powerful.

In an effort to not have to repeat code in the engine for different situations (in essence staying very modular), I designed most of the graphic routines so they can be used in one of three ways:

(1) Draw directly on any given DC
(2) Draw on a Printer
(3) Draw on a Canvas control

The DC versions of the routines are the core of the graphics engine. The Printer and Canvas versions are simply wrappers over the DC versions, where the DC is already provided (for the printer or canvas).

This makes the graphics engine very powerful. While it makes the code for the printer and canvas control easier and cleaner (no need to track DC's), you still have access to the DC versions of the routines so you can literally draw on anything that will provide you a DC. This is very useful when working with third party graphic tools or controls and especially when working with EZGUI's own OwnerDraw features. All the DC graphics commands can be used to customize any control (or menus) that supports ownerdraw.

EZGUI 5.0 even has a number of features such as accessing window DC's directly (or even the desktop) to draw on or to copy images from. If you need low level drawing features, EZGUI has them. If you need high level drawing features, EZGUI also has them.

Now the interesting thing about EZGUI's graphic engine is that there is no need to remember to free graphics objects, like Bitmaps, Brushes, Fonts, etc. While EZGUI allows you to free them via code, to simply free up resources used by windows, there is no need to, since EZGUI tracks them all and will delete all GDI objects when your app terminates.

Also there is no need to select objects into DC's and then have to remember to select the prior object back in. EZGUI doesn't require selecting of objects into DC's. You simply choose what to draw and EZGUI handles all the DC changes internally and always returns the DC to where it was previously, after you draw.

This way you concentrate on drawing and not on all the low level stuff of creating a DC, selecting DC objects, restoring DC's and deleting GDI objects.

EZGUI even provides a number of high level graphic commands which make things like Ownerdraw simple. EZGUI 5.0 has its own simplified command set for drawing 2D and 3D colored buttons and a variety of other control/menu items.

EZGUI provides a complete Printer graphic engine so you can easily write printer routines which handle most(if not all) of your printer needs.

Where EZGUI gets exciting is the Canvas control!

Rather than simply use a Static control (like PowerBasic does), EZGUI 5.0 provides a real true Graphics control, designed from the ground up specifically for your graphics needs. Since the Canvas is a true window control, you can have as many controls as you like. You are not limited to some kind of set buffer limit for graphic buffers. It also has many more features than what is built into the PowerBasic compiler.

The EZGUI 5.0 Canvas control is very powerful and offers many very advanced features.

(1) It supports either Device Dependent Bitmap Buffers (the fastest repaint) or 16, 24 or 32 bit DIB section Bitmap Buffers. You chose which you prefer!

(2) It supports Double Buffers. One is a foreground Buffer (what you actually see) and the other is a Background Buffer. You can copy images from one buffer to the other and draw on either.

(3) It supports direct access to pixel data of DIB section Buffers. This is very important, since it allows you to write very fast pixel manipulation routines using pointers directly to the pixel data. You can write things like image filters, for example a gray scale image filter, very easily. Also the beauty of direct access to a DIB section, is that it is faster than using DIBSet or DIBGet API pixel functions (or the PowerBasic) to set and get blocks of pixel data. Such functions require moving the data to a string buffer to manipulate and then moving it back again. This is two extra steps, simply to change the pixel data. EZGUI allows you to access the pixel data directly without having to move the data first.

What kind of drawing commands are there?

Not only can you draw Text, Shapes (lines, circles, etc.) and Bitmaps, you can also draw icons, images from imagelists (which can have transparent pixels), Gradients, 3D Gradients, draw RTF text (rich text from a Richedit control), tile bitmaps and more. EZGUI 5.0 introduces the new image filter engine with 22 built in image filters, when drawing Bitmaps. You can convert a bitmap to grayscale on the fly. You can convert and draw a bitmap to a colored tinted image on the fly.

EZGUI 5.0 introduces relative coordinate Polygons or PolyBeziers! This means, rather than define the actual coordinates for the shape (polygon), you can define its relative coordinates within a 1 x 1 square box (using decimal values) and then draw the shape as many times as you want in different locations on the Canvas control. EZGUI will even scale the polygon. You simply define the rectagular area where the polygon will be drawn and then EZGUI will calculate the actual coordinates for all its points for you.

Here is an example:


' defines a upside down triangle
EZ_DefPoly  "(0,0)(1,0)(.5,1)(0,0)"EZ_Color 0, 2EZ_CDraw %EZ_Poly, 0,0, 32, 32,1, 1
EZ_CDraw %EZ_Poly, 64,64, 32, 32,1, 1

EZGUI 5.0 even allows you to draw on a Canvas control a vector image defined using its own Turtle Graphics macro language (which can also be drawn in a Turtle control as well), as if it is an object.

EZGUI even allows you to create Bitmaps and use them directly as image buffers

Now if this isn't enough, EZGUI 5.0 has its Sprite Engine for use on Canvas controls and it has been improved over the previous version of EZGUI.

Sprites are image buffers themselves which can be drawn on (or simply copy a Bitmap too) and are assigned to Canvas controls. Sprites can have multiple Frames, for animation purposes, can be shown or hidden, flipped vertically or horizontally and can be moved to any position on the Canvas control. EZGUI automatically updates the Canvas image so the sprites are merged with the Canvas control image.

Sprites can also be Anti_Aliased and one of the more exciting features is the new AlphaBlending, where the sprite is semitranparent (or translucent). Sprites can have fully transparent pixels as well.

Sprites are useful for more than just Game development, but can be used for all sorts of business applications. Imagine using sprites for overlays for images, like a weather map which might have multiple overlaps (roads, streams, weather). EZGUI 5.0 even uses the internal sprite engine to impliment the new Effects engine when drawing on a Canvas control. Turn on the effects engine and what ever is drawn next is drawn to a temporary buffer. Then turn off the effects engine and that buffer is copied to the Canvas using effects similiar to sprites (like alphablending, anti-aliasing, etc.).

Also EZGUI's graphic engine will run even on older operating systems, like Windows 95 without the need for any special runtimes (like DirectX or GDI+ or OpenGL). This allows you to support older computers, which increases the market for your software.

Since Sprites are themselves independent image buffers, they can be dynamically changed and drawn on at runtime. This means you are not limited to sprites which are simply loaded bitmap files. You can dynamically create your sprite images and even change them. Sprites can even be used as part of the drawing engine, as a middleman, to get anti-aliasing from other graphics commands. Draw using standard drawing commands on a sprite buffer and then tell EZGUI to draw the sprite directly on the Canvas controls image buffer (permanently). This will allow you to anti-alias the graphic object.

Now add to all of this the many other Graphics features in EZGUI 5.0, such as the Turtle Graphics Control (a vector based graphic control), the Shape/Hot Spot control, the MCI control (display video, play audio files, etc.) and more, and you have a powerful graphics tool for building advanced GUI programs.

Now remember, that all of this is part of the complete EZGUI package. Not only do you get all the GUI commands (Forms/controls) in EZGUI's runtime engine and its Visual Designer/Code Generator, but you also get a complete Graphics (and print) engine builtin. Its all one complete product!

EZGUI 5.0 has expanded upon the previous version of EZGUI, with more support for working with DIB's, image rotation (when drawing bitmaps) and more. For example with one command you can draw a bitmap and rotate it, alphablending and scale it all at the same time. There is no single Windows API which does this, but EZGUI combines a number of features in Windows to accomplish this task and it works on all versions of Windows from XP to Windows 7.

If this is not enough, the new glCanvas control with its built in OpenGL based 3D scripting language is alone worth the price you pay for EZGUI. The glCanvas control is a real control, so you can have multiple 3D controls on a single form. It was designed to work with OpenGL 1.0 or better, so even older legacy computers likely can work with this control.  EZGUI can load STL 3D models lightning fast too. On a nearly 9 year old Windows XP computer, it can load an STL model with half a million  polygons in about 2 seconds. On a more modern computer is would be significantly faster too. When I recently downloaded another PowerBasic developers sample application with its own Graphic engine, on this older computer it took over 45 seconds to load an OBJ format 3D model with only about 100,000 polygons. While EZGUI does not support the OBJ format, it does support a much faster and simpler file format which is STL and EZGUI could load that same 3D model (as an STL) almost instantly and a 3D model with about 5 times the number of polygons (1 hald million) in about 2 seconds. Also unlike that other PowerBasic graphic library there is no drawing code required. With EZGUI you simply load a model into a controls 3D world and then change its coordinates (to move it). Each control can be loaded with as many 3D models in a scene as you like and the control handles all the drawing.  Because EZGUI uses an easy to use scripting language, there are no API's to learn, no OpenGL to learn. Just simple scripts to load an animate a 3D scene.

If you want advanced graphics capabilities in your apps, while it still being easy to use, please take a serious look at EZGUI 5.0
Chris Boss
Hero Member
Posts: 2754

View Profile
« Reply #4 on: July 30, 2012, 05:06:13 PM »

Part 5: Price and Value!

One of the first things people notice about EZGUI 5.0 is the price. With all the other lower price alternatives, why is EZGUI 5.0 priced so much higher?

First, it should be noted that EZGUI is in its 5th generation, unlike other tools which are only in their 1st or 2nd generation. I have had a chance to weigh out marketing factors such as price in earlier versions (EZGUI 1.0 sold for only $99). I found that the price often reflects the value of the product and it also effects such things as tech support. By targeting a lower price market, I found that it tended to effect decisions I made about the features I would put in the product and how much time I would spend on tech support.

Have you ever wondered why most of the big software companies today, charge you high prices for tech support subscriptions and any free tech support offered, likely never gets you in contact with a real person, or at least not quickly. Even phone support is done by machines, rather than real people. Why?

Because it costs a lot for real tech support and most people want low prices for the product.

In EZGUI's 3rd generation, I made the decision that by charging a slightly higher price up front, I would be calculating into the product decent tech support (quick, detailed and helpful).

To appreciate the quality of my tech support, simply scan these forums and see not only how often I post answers to questions, but how detailed it often is. I try to post source code when I can as well.

One of the things you can't see from the forums, is how much time may be spent in finding the answers. At times I have spent hours trying to track down a problem or in researching an answer. While most customers don't need that much help, when it is needed, I try hard to be there.

I also get a good deal of email from customers where they ask questions and you won't see this reflected on my forums. At times some of the email replies are very long and detailed explanations of things.

This is part of the cost of the product!

Now the rest of the products value has to do with both features and productivity.

First, when it comes to features, you need to actually calculate what is really being offered.

EZGUI is more than just a Visual Designer!

EZGUI does have a powerful Visual Designer which allows you to build applications quickly. That has value!

EZGUI is also a runtime!

The EZGUI command set is simply extensive!

While there are about 800 commands in the command set, many commands work on multiple control classes, so it is like having many hundreds of commands more. Two commands alone encapsulate over 150 API messages for use with a variety of controls.

EZGUI is not simply a wrapper over API functions or messages. Often the commands are quite high level. Some even consisting of hundreds of lines of code in them.

Now add to this, EZGUI's engines!

The engines in EZGUI go beyond just commands. They are internal engines which handle complex tasks (like drag and drop, subclassing, event generation, etc.) This is why when working with the common controls, it is so much easier, because you don't have to write complex WM_NOTIFY code in your apps. EZGUI is already processing the most important notification messages, processing them properly and generating easy to use events from them.

EZGUI 5.0 has over 100 actual types of Event it generates. You don't have to even write a single line of code in many instances to get these events. They just occur and the event engine passes them to your application. This is all part of EZGUI's internal engines.

Now these three features alone (Visual Designer, Runtime command set and Engines) are worth quite a lot.

Now add to this, the custom controls added to EZGUI 5.0. How much would you pay for each control type?

EZGUI 5.0 has:

- masked edit control
- MCI control
- Turtle Graphics control (vector based)
- Canvas control (raster based with 2D Sprite engine)
- Shape/Hot Spot/SplitterBar control
- Drag Handle control
- Properties Listbox control
- Files Listbox control
- glCanvas (OpenGL 3D)

What are these components worth to you?

If you purchase separate products for the following:

(1) Visual Designer
(2) Graphics Engine
(3) Printer Engine
(4) GUI Library
(5) Custom controls (like masked edit, MCI, properties listbox)

What do you pay for each of them ?

When you add up the price for buying separate components for many of these , and other tasks, how much does it cost?

With EZGUI you get all of it in one package!

Lastly, one aspect of value which is often overlooked is what I will call "code maintainability".

Especially when writing commercial applications, it takes time to write the code and you know the old saying "time is money". But also consider how much time is spent on maintaining code?

One aspect is in updating it and adding improvements. The other is in debugging code.

One of the reason programmers choose the BASIC programming language is because of easy to read code, fast coding and code maintainability. One can put aside a BASIC program and come back to it years later and they will likely be able to figure out how it works in a reasonable amount of time. Not so with some other programming languages.

Now BASIC for windows is complication by the fact that a lot of API code is necessary and that is definitely not readable or easily maintainable. Can you put aside your API code and come back to it years later and understand what it is doing?

While EZGUI does have a learning curve to it, like anything else, you will find the code is very readable. You can understand what it is doing. Now some Windows tasks are complex, so even the EZGUI code for that task may be a little more than simple, it likely will be much easier to read and understand than the comparable API code for that task.

Especially for software that will require long term maintainance, EZGUI offers you something that can't have a price put on it.

Simply put, do you value your time?

What is it worth to you?

EZGUI 5.0 makes a programmer productive at the highest level I personally can make it. That was my goal in its design.

If on average, when you have to handle a difficult programming task, if EZGUI only takes you 15 minutes compared to an hour using the API, how long will it take before EZGUI has saved you a significant amount of time?

Just do the math!

If it takes an hour to write a simple EZGUI application, that would take you 4 hours using the API directly and you get paid $30/hour, then you have saved $90.

I have a lot of experience in writing custom software for a variety of businesses and I know that most complex software has many hundreds of man/hours in them (sometimes even thousands). Just imagine the savings in the long run, when using a product as productive as EZGUI 5.0 is?

The value of a product is far more than what meets the eye. One must calculate all the benefits of the product and all the ways it may save.
Pages: [1]   Go Up
Jump to: