Sale - Low cost EZGUI Designers (PV and DLG) - Save!

[Chris Boss]

From June 10 until June 18, 2008 you can save money on either the EZGUI Utility Dialog Designer 4.01 or EZGUI 4.0 PV (Personal Version).

The EZGUI Utility Dialog Designer 4.01 is an amazingly low cost DDT (100% code) designer. The regular price is $29. Now get it on sale for just:

$14.95 (US)

This is almost half off!

The EZGUI 4.0 Personal Version (PV) has nearly all the features of EZGUI 4.0 Pro, with a just a few limitations and a different software license (for personal use only and not for commercial distribution). EZGUI 4.0 Pro sells for $249. The normal price on the personal version is $49. Now get the personal version for just:

$29 (US)

Don't under estimate the power of the Utility Dialog Designer. While it only supports the standard controls directly, it can access other controls via the custom control object, as well as third party controls. You can produce extremely small (and reliable) applications with this designer. It also sports a similiar Smart Parser as does my professional tools (ie. EZGUI 4.0 Pro) to make it easy to move seamlessly between the designer and your favorite code editor.

The EZGUI 4.0 Personal Version (PV) can be used by hobby programmers who have limited resources. Its great for education settings as well. It can also even be used by businesses for inhouse software (license prevents distribution, but it can be used commercially inhouse). Its a great way to get a feel for EZGUI 4.0 pro, without the high cost.

Don't let this sale go by.

Where can you get such great tools for such a low price ?

[Chris Boss]

EZGUI 4.0 Personal Version (PV) info

Here is a chart which lists the differences between the Personal version and the Pro version:

http://cwsof.com/newweb/compare.htm

Full Size Screen Shot: http://cwsof.com/ez4pv.png

Visit my web site for more info about EZGUI 4.0 (both Pro and Personal version) at:

http://cwsof.com

[Chris Boss]

EZGUI Utility Dialog Designer 4.01 info

For more info about the Utility Dialog Designer read these posts:

http://www.powerbasic.com/support/pbforums/showthread.php?t=36451

http://www.powerbasic.com/support/pbforums/showthread.php?t=36273

This Designer is a 100% source code designer (no runtimes).

It uses Library code (an include) to handle a lot of functionality so the main source code is simple, clean and easy to read. The code is event based which is easier than message based, IMO.

The generated code (and Library) are reliable so few surprises when compiling.

This is not just some beginners tool. It is a professional level designer for generating simple utility applications. It can even be used for larger applications if you want to. There is no limit on the number of forms. It also supports third party custom controls like EGrid or SIgrid.

[Chris Boss]

Sale Prices

The sale prices won't be seen until you get to the actual order page. To save time, here is a link directly to that order page:

http://cwsof.com/order.htm

[Chris Boss]

Have questions ?

If you have any questions about either Designer, feel free to email me at:

[email protected]

or

[email protected]

[Elias Montoya]

Chris i have a question that maybe EZGUI can solve:

Suppose i have a GIF animation of a letter that is being put in an envelope,
then the envelope closes and flies away.

Is there a way (Using EZGUI) to read every frame of the GIF and convert it into a region
to be aplied on a dialog, while the image is painted on the dialog to simulate a
desktop-level animation 'without a dialog'?

P.S. An executable example would be appreciated.

[Chris Boss]

EZGUI doesn't support GIF images.

The Canvas control can regenerate a region, every time the image changes, but the Forms can't (they can only be defined once at creation).

[Chris Boss]

Elias, now if you are wlling to combine some API code, you may be able to do this.

Changing a forms (dialog) region via the API is quite simple.
The SetWindowRgn API function can be used to change a windows region.

All you need is the region.

If you can load the GIF (using the OLE IPicture interface) and convert the frames to bitmaps, you could do this using EZGUI commands:

- Create a Splash Form (no borders or caption)
- Create a Canvas control that fills the entire form
- Draw a Frame from your GIF animation (requires a Bitmap)
- have the Canvas generate a region from current image

Now using the API, call GetWindowRgn using the handle to the Canvas. This will return a copy of the Canvas region. Then use SetWindowRgn to pass the region to the parent Form.

In essence, the Canvas does the region generation for you and also is your background. All you need to do is copy the region and pass it to the parent form.

Also, as far as the GIF conversion, if you can get the GIF frames converted to bitmaps, it could be drawn one time into a Sprite (with the same number of frames). The Sprite then could be used as the mechanism to draw the frames. EZGUI provides a command which can force the sprite image to be drawn as part of the Canvas background. You simply erase the Canvas and draw the next sprite frame and then generate a new region.

[Chris Boss]

This is a great offer, so don't let it go by.

Where can you get a Visual Designer for DDT for only $14.95 ?

Don't let the low price fool you.

This is a professional level Visual Designer. While it does not directly support the common controls (the designer is for building utility apps), you can add them via the custom control object. The Library code supports the %EZ_Notify event (WM_NOTIFY) and provides the EZ_GetNotify command which makes processing notification messages much easier. You can also extend the event engine with your own custom event handler.

In the right hands, this designer could be used to build large complex applications.

Because the generated code uses a modular library for much of the event handling, as your application gets larger (more forms), the savings on application size increases.

The Designer (and library code) supports Colors, Fonts, Images and simple regions (controls can be an ellipse or rounded rectangle).

You can add items to the listbox and combobox easily in the designer like this:

"Apple|Orange|Pear|Watermellon|Grape|"

The PB Graphic control is also supported. This means if you write a lot of apps which use Pb Graphics, this is a great tool for you.

The Library code provides resource tracking, so you don't have to worry about freeing fonts or brushes. Bitmaps are also tracked and a subroutine is generated which can be called which will free those bitmaps (you can call this subroutine when the form closes or when the app terminates).

A unique event, called %EZ_Loading, is provided (no API equivalent) which allows you to change the control creation parameters via an event, before the control is created. This allows you to dynamically change a controls creation, without modifying the control creation code generated by the designer.

Controls also get a unique event, called %EZ_Loaded, right after the control is created. This allows you to execute code immediately after the controls creation, via an event, so you don't have to write code in the GUI generated code.

Since the Designer generated code is event driven, you don't have to use API constants for messages (for the standard controls). For example, you won't use %BN_CLICKED for the Button control and %STN_CLICKED for the static control. You will use the event %EZ_Click for all controls, that support a click event. For example, the Edit control, Listbox control, ComboBox control and Scrollbars all get the %EZ_Change event.

The Designer also supports Third Party custom controls (ie. EGrid) visually in the designer. It is easy to add new custom controls. As long as the custom control is a DLL, can be created using CreateWindow (a true window class) and has a simple registration function call, you can write a EZC file (EZ control definition file) for the control using NotePad, copy the DLL to the same folder as the designer and the designer will be able to load and display the custom control.

The Designer supports user created code plugins, which allows you to parse generated code before it is sent to your code editor.

The Designer also supports code templates, which allow you to add your own user defined code to some areas of generated code.

A template for user defined events is also provided so you can add events based on messages sent to the dialog procedure. Here is the code in that template:

' ---------------------
' User events template
' ---------------------
'
' This code is public domain and can be modified any way you choose and distributed to third parties.
' The Functions name and parameters though must not be changed!
' Define your own Events here!
' User defined Events should start with the value of %EZ_User so they don't conflict with existing events.
%MY_LButtonDown     =    %EZ_USER + 1
FUNCTION EZLIB_UserEvents(BYVAL hDlg AS LONG, BYVAL Msg AS LONG, BYVAL wParam AS LONG, BYVAL lParam AS LONG, BYVAL EventAddress AS DWORD, RV AS LONG) AS LONG
     LOCAL CVal&, Cancel&
     ' if function returns non-zero then no more event processing is done by EZ Library code for this message
     ' RV is the return value for to the Dialog procedure. Set to non-zero to prevent default processing.
     SELECT CASE Msg     ' Window messages
          CASE %WM_LBUTTONDOWN
               CVal&=lParam   ' pass mouse position in CVal&
               EZLIB_SendEvent hDlg, %EZ_Window, %MY_LButtonDown, CVal&, Cancel&, EventAddress
               RV&=0
               FUNCTION=1
          CASE ELSE
     END SELECT
END FUNCTION

This allows you to expand upon the event engine yourself.

Another nice feature is Form Templates. You can save any Form as a Template, so it appears in the "New Form" dialog. When you create new forms, you can select from any previously saved form template. This makes it easy for you to design commonly used dialogs and reuse them in other apps.

You may ask,

If this Designer is so powerful and is a professional tool, why do you sell it so cheap ?

Because this designer is just my entry level DDT Designer (which is why I call it a Utility Designer). Another Designer (based on the same code and compatible) is coming which is the advanced version which will support all in this designer, plus the common controls (has a toolbar builder), a subclassing engine, the richedit control, a layer engine (for use with Tab controls or for building wizard style dialogs) and more.

You will be able to upgrade to this advanced designer at a discount off the full retail price. Buy the Utility Designer now and save later when upgrading to the pro version (called the "Studio Dialog Designer").

For the price I am selling this Utility Designer for, even if you have invested already in another Designer, you can easily afford to get this one too.

Just getting a chance to examine the Library code provided will be a learning experience. I write clean, easy to understand, code and you can learn a lot from examining my library code (the code is copyrighted and can't be distributed, but you will learn a lot about the API from how it is written).

The library code also demonstrates good modular code design, which I feel is important when dealing with the API.

While I haven't tried it, I don't see any reason why someone couldn't use this Designer and integrate PB Forms generated code into the app (putting all PB Forms code in includes). With a little effort you could even take advantage of my Event engine, with those PB Forms dialogs. You can even add PB Forms to the Tools menu, so you can access it from the Designer.

For example, to take advantage of the Event engine in a PB Forms dialog you add to a project (as an include file), all you would have to do is write the dialog procedure like this:

CALLBACK FUNCTION FORM1_DlgProc
     SELECT CASE CBMSG
          CASE ELSE
     END SELECT
     ' Pass Messages to EZGUI Default Event Generator
     ' make sure CODEPTR parameter points to _ParseEvents routine for this form
     FUNCTION=EZLIB_DLGEvents(CBHNDL, CBMSG, CBWPARAM, CBLPARAM, CODEPTR(MyPBDialog_ParseEvents))
END FUNCTION

The events then would be forwarded to a parse eventsd routine which you can write yourself like this:

SUB MyPBDialog_ParseEvents(BYVAL hDlg&, BYVAL CID&, CMsg&, CVal&, Cancel&)
     IF PreProcess_Events("MYPBDIALOG", hDlg&, CID&, CMsg&, CVal&, Cancel&) THEN EXIT SUB
     SELECT CASE CID&
          CASE %EZ_Window     ' this is the Dialog
               ' you can process the event code here or pass it on to a subroutine
               FORM1_Events hDlg&, CID&, CMsg&, CVal&, Cancel&
          CASE  %IDD_FORM1_BUTTON1
               ' you can process the event code here or pass it on to a subroutine
               FORM1_BUTTON1_Events CID&, CMsg&, CVal&, Cancel&
          CASE ELSE
               ' you can process the event code here or pass it on to a subroutine
               FORM1_Events hDlg&, CID&, CMsg&, CVal&, Cancel&
     END SELECT
END SUB

The CMsg& parameter passes the Event constant (ie. %EZ_Click).
The CVal& parameter passes info about the Event (ie. a scrollbar has the current possition here. a Combobox has the selected item index here.).
The Cancel& parameter is used for returning a Cancel default processing flag.

In essence, you can have the best of both worlds by integrating PB Forms code into an EZGUI Utility Dialog application. The only events you wouldn't get for the (PB Forms) Forms or Controls is %EZ_Loading and %EZ_Loaded.

Also, by getting this Designer into the hands of as many PB'ers as possible (by selling it for such a low price), I can encourage development of Third Party controls, Code Plugins, Code Templates (even form templates) and User Events routines by the community for use with the Designer. The more support it gets, the better the experience for everyone.

[George Towler]

That really is cheap, especially with the weak dollar BUT a while ago I remember a post about a personal version of one of the PowerBasic RADs which included a splash screen in the executables it generated. I'm sure lots of people wouldn't care but I think it sucks. Does EZGUI PV have this feature?

[Chris Boss]

George,

I have two different products on sale.

EZGUI 4.0 Personal Version, which is only for personal use, which does have a splash screen. Remember, this is a personal version of a $249 professional product, so the splash screen is reasonable.

Above, though I was discussing the EZGUI Utility Dialog Designer 4.01, which generates 100% code (no runtimes). This designer is for building applications which you can distribute and there is no splash screen (since there is no runtime). You can build quality commercial applications with this designer. For $14.95, you can't beat the price.

[Chris Boss]

Test Drive EZGUI 4.0 Pro - Buy Personal Version

EZGUI 4.0 Pro is worth every penny of its $249 price. In the right hands, it gives a programmer amazing power over their software development.

The problem is that each programmer has a different style (and needs) of programming and what works well for one may not work well for another.

The Personal Version (currently on sale) of EZGUI 4.0 is a great way to take a test drive of EZGUI 4.0. For a number of reasons (one is to protect some proprietary information, such as the include files) there is no trial version of EZGUI 4.0 Pro. The Personal Version, especially when on sale, is a great way to take EZGUI for a test drive and not risk much money. Unlike a trial version, which usually has a time limit, the Personal Version is a licensed version which you can take your time learning how to use. You can build all the inhouse software you like with it, even for a business. You even get tech support with it.

If you like the Personal Version, you can later upgrade to the Pro version.

To see the differences between the Personal version and the Professional version check out this web page:

http://cwsof.com/newweb/compare.htm

While my Dialog designers are for those who want 100% source code, EZGUI 4.0 Personal (and Pro) use a runtime instead (515 KB DLL). The runtime offers something not found in 100% source code tools, which is a complete GUI Engine. There are some advantages of using a runtime GUI engine. Errors caused by API include files are eliminated, since most EZGUI applications don't need to use any API includes. Compile time is much faster, since the API includes (which are huge) are not needed.

A runtime GUI engine allows better modular design, since a well designed DLL can take advantage of existing code and reuse much of itself. EZGUI is extremely modular in design and the runtime DLL contains a hugh feature set for its size. EZGUI is more than just a Forms/Controls creation engine. It has a number of built-in custom controls, a graphics engine, a print engine, a sprite engine, a drag/drop engine, a subclass engine, an ownerdraw engine, an event engine, a resource engine (tracks resources and cleans up when app terminates), etc.

The features go far beyond the actual number of subs/functions in the DLL (which is over 620). When you add up all the internal features (engines) which are doing work for you, some commands which work with multiple control classes, some commands which handle dozens of tasks, the entire feature set is amazing.

EZGUI , while easy to use, was designed for the power user. It takes time to grasp many of its concepts and one will not appreciate it fully until you have time to push it to its limits.

What determines whether one will like EZGUI or not ?

Each programmer has different needs and style. EZGUI can not be everything to everyone. It has strengths and weaknesses, like any software tool. IMO, users who tend to be disatisfied with it fall into a number of catagories:

(1) Those who want a VB clone.
EZGUI is not a VB clone and never will be. The Designer, while very powerful for its designed task, is not like Visual Basic and if the Visual environment and its similiarity to your VB experience is the most critical thing to you, then EZGUI is not for you.

(2) Those who don't like writing code.
EZGUI's most powerful feature is its GUI engine. The command set is easy to learn and to use, yet it is very powerful and in the right hands it can do some amazing things. You can customize your applications so they are leading edge products. But, if you want the Visual Designer to do all the work for you, prefer to simply plugin in component after compinent (ActiveX controls), but hate writing code, EZGUI is not for you.

(3) Those who want a game engine.
While EZGUIs graphic engine is extensive, it is not a game engine. There is no DirectX stuff. Its graphic engine was designed for building business applications, which need graphics, but don't need the leading edge game stuff. EZGUI's graphics don't require DirectX, GDI+ or any leading edge operating system. It was designed so you can customize the look and feel of your application (ie. ownerdraw), as well as to be able to run on many different platforms (Win95 to Vista). For the kind of software I expect to be designed with EZGUI, multi-platform development and low hardware requirements are more important. If you want the latest, greatest Game platform, then EZGUI is not for you.

(4) Those who can't invest the time in learning.
While the EZ in EZGUI stands for "Easy to use", this does not mean there is no learning curve to the product. The GUI engine has over 600 commands in it, so of course some time is needed to learn how to use it. EZGUI is Event based and this takes some time getting used to. It may be different than your current coding style. If you are not willing to invest the time into learning the product to get the most out of it, then EZGUI is not for you.

Then who is EZGUI for ?

Who will benefit from it the most ?

EZGUI is for programmers, who want a complete solution. It is for programmers who take their software development very seriously and who are willing to invest some time in learning how to get the most out of their tools. The most successful EZGUI users are the ones who regularly ask questions on my forums (or by email). If they don't understand something, they get help. For example, I had one customer who emailed me over 70 times, asking one question after another. Initially the customer struggled a bit with the product, simply because it was likely different than what they had previous worked with. The customer kept asking questions. At one point, the customer had one of those "I get it" moments, where its like a light turning on and you go from darkness, into a lit room. You finally get it. It makes sense. This is what I mean by investing time in the product.

One of the reasons I charge $249 (for the pro version) is that, I want the customers to ask lots of questions. I planned on it! I sell EZGUI for a price that takes into consideration time I will spend giving the customer one on one support. I expect to spend a number of hours with each customer. If they want to telephone me, I will spend time on the phone helping them. If they inundate me with emails, I will answer each and every one. I really do! Now if you have a spam filter which purges emails I send, thats a different story (which is one reason I encourage users to use my online forums, rather than emails), but I do actually answer the emails I get and quickly. I visit my forums multiple times a day to check for questions and I try to post answers to all the questions I possibly can. I do research when customers ask questions. I will research the API docs for things I don't know off hand, for customers.

Tech support is key to getting the most out of EZGUI.

Another aspect of those who get the most out of EZGUI is whether you like to write code. EZGUI does a lot for you with its Visual Designer, but I expect users to write code. The GUI engine was designed for those who write code and lots of it. I personally am a "coder". I like writing code and I an not afraid to write lots of it. They key is having the command set which gives you the power to do the things you want to do. EZGUI's extensive command set is such a tool. While EZGUI has many high level commands/features , it also has many low level commands/features . The idea is, if you need something different, you should be able to code it with EZGUI. Maybe Windows doesn't do things the way you like. With EZGUI you should be able to customize it somehow (ie. ownerdraw) or subclass the control and do some preprocessing of events (ie. mouse or keyboard). With EZGUI, the tools are there, you just have to be willing to write some code to do it.

EZGUI is a balance between high level features and low level.

The GUI Engine is the core part of the product.

As far as your style of writing code, with EZGUI you need to be flexible. I know many programmers have very specific likes and dislikes about how their code should look. There is absolutely no way to please everyone when it comes to code generation. The code generated by the EZGUI Designer follows some rules, which are necessary for its Smart Parser to work and also are beneficial for good readability and good modular design. It is possible to make some changes to the generated code via user created plugins, some things you just will have to live with.

For example, I prefer the use of data type indentifiers (MyVar& rather than MyVar as LONG). This may urk some people. Maybe its because I have been programming using BASIC since the 70's, but even now with the ability to use a different syntax, I still prefer indentifiers. One is saves time coding. It is much faster to simply write A& then A AS LONG. Second, I think it makes code more readable, since you immediately know what are variables in the code and what type they are.

Fortunately, the code generator doesn't have to generate an awful amount of variables, so even if you don't like identifiers, it can be lived with by most.

What you will find is that the code is very readable and very modular, thats for sure. EZGUI users who are most concerned about readability (also maintainability) and modular design, will appreciate the code generation, even if it is not exactly like their style of coding.

If you want to be able to go back days, months, years later and be able to read the code and understand it, you will like EZGUI.

The users who like EZGUI the most, are the ones who are willing to work with the tools provided to find ways to make it more productive for themselves. For example, the Designer provides a number of ways to extend it. It supports code templates to add library code to generated code. It supports code plugins, where the generate code is passed to first, before being sent to your code editor, so you can modify it. Users who use these advanced methods to improve the code generation, so they can have a more personalized experience, enjoy the product more and are more productive.

If you are stickler when it comes to programming tools and it has to be exactly your way, then you may not enjoy the product as much. If you are willing to use the tools provided which allow extending the tool so you can customize it, while being willing to tolerate a few exceptions where it may not be possible to get exactly what you want, then you will likely be more happy with the product.

One has to appreciate that when using a code generation tool, its like two programmers working together. No two programmers think alike or work alike, so they have to make compromises to work successfully together. With a code generator, you have to be willing to do the same, since the code generator is your partner in coding.

The happiest EZGUI users tend to be those who say, "I really wish it did it this way (and maybe you will add it to the next version), but I can work around this".

I really listened to my customers during the last development cycle (for EZGUI 4.0 pro) and many of the features are because of the things they suggested. The problem is no two programmers thing alike and you can't please everyone. I made compromises so as to make as many happy as possible. They key is not whether a tool works exactly as you want, out of the box, but whether solutions, one way or another, can be found so you are productive. Its the final outcome that is important. Those who are willing to make the investment in time to fine tune the EZGUI environment to their needs, will appreciate it the most. I had one customer who wrote his own code plugin, which made some majors changes to the code generation, but in the end, he got what he needed.

[Chris Boss]

Time is running out. This sale ends soon, so don't let it go by.

The Dialog Designer is the best deal you will get on any Visual Designer. For $14.95 you can't beat the price.

[Chris Boss]

Sale ends today.

I will leave the order forms available until the morning so those outside the USA can still order last minute.

Don't let this deal go by.

[Chris Boss]

Sale has ended

Sale has ended!