Sale Continues (EZGUI tools) (Beat the Recession)

[Chris Boss]

All of the previously posted sales have ended!

Good news though!

The response was so good for the previous sales that I am offering some new ones.

From February 1, 2009 until February 28, 2009 the following are on sale:

-----------------------------------------------------------
EZGUI 4.0 Pro (new users) for only $99 (a savings of $150)
(note, NO other software is bundled with it, like the previous sale)
-----------------------------------------------------------
'
-----------------------------------------------------------
Upgrade from EZGUI 1.0, 2.0, 3.0 or EZGUI 4.0 Personal version to
EZGUI 4.0 Pro for only $49 (a savings of $110) (savings of $150 for PV users)
(note, NO other software is bundled with it, like the previous sale)
-----------------------------------------------------------
'
-----------------------------------------------------------
EZGUI Utility Dialog Designer for only $14.95 ( a savings of $14.05)
-----------------------------------------------------------

Note: I dropped the upgrade price back to $49. This should encourage all EZGUI users to upgrade.

[Chris Boss]

For more information about both products read the following threads:

EZGUI 4.0 Pro:

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

EZGUI Utility Dialog Designer:

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

[Chris Boss]

The EZGUI approach:

EZGUI is in its fourth generation now and over the years I have followed this approach to its development:

(1) The GUI runtime was the most important part of the product. The use of a runtime separates EZGUI from other products and for good reason. By developing a GUI engine I would have complete control over how applications developed with it would run. The first goal was to develop an engine that was reliable. It is possible to crash (GPF) applications when one uses the API. The more complex API's used, the greater chance one will may inadvertantly produce a resource leak or some other flaw which could bring ones application to stop.

With a runtime, I could add paramater checking and safety checks to make sure the application remains stable.

The second goal was to add a significant feature set. The approach was to ask the simple question "what would most Windows developers want to be able to do in their apps ?". This meant more than simply adding basic control support. In each generation of EZGUI, I continued to push the limit of what controls could do. I also added my own custom controls to fill in the gaps.

The feature set though goes far beyond just the controls.

This is where EZGUI differentiates itself from other Design tools.

For example, one of the most common tasks most programmers need is to be able to print to the printer. EZGUI provides a complete print engine, but goes further than the basics. Not only can it print text, shapes, and bitmaps, but it can print Gradients, Turtle Graphics (vectors graphics) and even the contents of a RichEdit control (RTF). Also there is support for building your own Print Preview window (via the Canvas control being integrated into the print engine).

Many programmers want more control of how the controls look. EZGUI again goes beyond other tools, by providing a custom draw engine (change the font and colors of items in some controls) and an ownerdraw engine (draw the items in some controls and menus exactly the way you want).

EZGUI's choice of custom controls also differentiates it from other tools. Rather than a bunch of high level UI controls, some of the custom controls are slighty more low level, so you can be more creative. The Canvas control has an integrated Sprite engine for building animated graphic orientated controls. The MCI control adds multimedia capabilities (video, audio, MIDI). The drag handle control is used for building drag and drop (WYSIWYG) style applications. The Turtle Graphics control gives you a powerful vector drawing engine.

Some of the more high level custom controls are the Files Listbox control, Property Listbox control and the Masked Edit control.

The runtime engine goes even further.

Some very complex tasks are built into the engine. One example is the drag icon feature, which impliments drag icons for the listview and treeview controls. This is very complex code and not easily done using the API. With EZGUI's runtime it is built in and easy to use.

EZGUI's Sprite engine is another very complex feature. Most API programmers don't have time to spend trying to build a complex Sprite engine. EZGUI's sprite engine not only animates (moves, hides/shows, animate frames) sprites (non-rectangular objects), but it also does click (mouse) and collision testing for objects. It also offers alphablending and anti-aliasing (not an easy thing to do). All of this is done via software (within EZGUI) and does not require DirectX, GDI+ or OpenGL.

The feature set is so extensive I can't do it justice in a few posts.

(2) Visual Design and Code Generation.
EZGUI provides a Visual Designer/Code Generator specifically tuned to the EZGUI runtime. Rather than attempt to emulate Visual basic or some other programming language, the Designer was designed to be attuned to the GUI runtime and its features. Many of the features of the runtimes are built into the Designer. For example, it supports things like Shaped Forms (non-rectangular Forms based on a Bitmap image). It supports 3D and 2D colored buttons. It supports all of EZGUI's custom controls (except drag handle). It has a Toolbar Builder Dialog, a Properties Listbox Builder Dialog, a menu Editor and a Turtle Graphics editor. It supports EZGUI's layer engine. Many of the options or properties for Forms and Controls are unique to EZGUI, since they are features of its runtime. For example you can define a Form as a Page Form (a child form on other Forms), a Rebar Form (a form designed to be used within a Rebar control) , a Pager Form (a form designed to be used within a Pager control), an Owned Form (works differently than a Page form, but is still a child form), etc.

By combining a Visual Designer specific to its runtime, EZGUI provides a powerful tool for building advanced Windows applications.

Now with this special sale, you can purchase EZGUI at a fraction of its original price. Don't let this sale go by.

[Chris Boss]

Benefits of an extended runtime engine:

Today with the economy affecting so many businesses, the old adage "time is money" comes to the fore when it comes to software development. The faster you can develop applications, the more it affects the bottom line of a company.

When developing an application there are multiple steps in the process. The first step is the visual design and basic layout. Each Visual Designer has a different approach and some may even be faster than others in this. But once you are past the basic layout of the Forms/Controls then you get to the hard part:

Making your software do something. Interacting with the GUI.

Where EZGUI shines is when you get to this step. The runtime engine is rich with features to allow you to do most anything you may need.

EZGUI users who take the time to learn how to use its many features are the happiest users, since they continue to solve problems, find solutions and build the core to their applications.

Its when you want to accomplish something unique and different that EZGUI helps out greatly.

For example, let's say you need to do the following. How quickly can you find the answers using the API ?

ie.

- Customize a Common Dialog or Browse Folders dialog by adding controls, processing events for existing controls on the dialog, changing the dialogs buttons look or painting a different background.

- Search items quickly in a Listview control within any combinations of columns (ie. match text in columns 1, 3,4 and 7 only as a group)

- impliment drag icon in a listview control and impliment autoscrolling when drag icon is at top or bottom of the list.

- customize each item in a listview, drawing custom images or text in different colors, fonts, etc.

- play a silent animation (AVI) in an animation control and to move to specific frames as desired.

- Play a video (mpeg, avi) in a control and to generate an event when the video ends or generate a flag event at specific intervals (time) or at specific positions within the video

- process a mouse click event for Listview control and to get not only the item index clicked, but the actual client coordinates of the click, the relative coordinates of the click within the subitem and the subitem (column) the click occurred. in just a couple lines of code.

- paint a custom background of a MDI Client control.

- customize a Tab control so it is uses custom colors (requires ownerdraw and background painting)

- paint a 3D background for a Toolbar control

- display a non-rectangular Form using a region based on a Bitmap background image (and paint the bitmap background)

- create 3D custom buttons or 2D custom buttons (using colors)

- Print the text of a RichEdit control to a printer or even to a window DC (ie. Canvas control)

- animate movable images (non-rectagular) over a graphic background, using frames for objects (object is animated) and anti-alias it and alphablend it

- display a Files Listbox using your own custom icons, rather than the system shell icons

- impliment a Rebar control using multiple Forms as Bands

- draw Polygons or PolyBeziers using relative coordinates, rather than absolute coordinates

- track mouse and bitblt contents of area where mouse is to a graphic window in real time (as mouse moves across the screen)

- Display the Windows Video Open File Dialog

- Enumerate every control on a Form (get a list) and get each controls ID, handle and type or class

- create a game Loop instead of a standard message

- process dropped files from Windows Explorer

- use a precision timer to exact timing (more exact than the standard timer which is limited to around 20 ms)

- estimate the speed of the CPU (real speed in execution)

- create DIB section Bitmaps and draw directly on them via their bits (no GET/SET blocks of pixel data needed, but direct access)

- Display either type of Help file (HLP or HTML)

- create your own custom Print Preview window

- get a specific list of resources in your EXE or an external DLL

- define Tray Icons (in task bar) and process the events for them, including being able to display a right click popup menu for the tray icon

- impliment a drawing drag rectangle for graphic programs (press mouse button down, then drag and a drag rectangle is drawn on the background (called "rubber banding") and then erase it when mouse button comes up

- custom paint the background in controls

- impliment a "snap to grid" like in Visual Designers when using drag/drop with controls.

Can you see how EZGUI goes beyond the basics, but gives you a feature set which deals with many advanced tasks.

Save time in software development.

Solutions to complex tasks is what EZGUI offers.

[Chris Boss]

Some unique features to the EZGUI Visual Designer:

Button Builder Dialog:



Label Gradient Builder Dialog:




Property Listbox control Builder Dialog:




Turtle Graphic Builder Dialog: (vector graphic macro language)



Toolbar Builder Dialog:

[Chris Boss]

Can you draw this visually with your Visual Designer ?

Notice some of the things that can be done visually with the EZGUI Visual Designer:

- Colored Tab controls
- Vertical Fonts on side Tabs
- 3D Gradient backgrounds (using ownerdraw labels)
- 3D colored Buttons in different styles and shapes (ellipse, rounded rectangle)
- 2D colored buttons
- real Line Shape control with different thickness lines
- vector graphic control

[Chris Boss]

Property Listbox control creates advanced GUI's

Do you want an advanced look to your applications ?

EZGUI provides and easy to use Property Listbox control which allows you to create an advanced GUI.

Heres the Property Listbox control:



The Property Listbox supports six data types:

1- Catagory Title

The Catagory Title is displayed in a 3D background to make it stand out.

2 - Color

This data field displays a color. When the item is selected a button appears to display the Color Common Dialog when clicked.







3 - Drop Down List

This data field displays a drop down list (combobox) which the user can select an item.




4 - Filename

This data field displays a filename and when the item is selected a button appears which when clicked displays the Open File common dialog.









5 - Text

This data field displays a user editable text field.




6 - User Defined

This data field displays a texbox and a button for the user to click. When clicked an event occurs which allows you to display your own input dialog.

[Chris Boss]

What are Sprites ?

What other Visual Designer/GUI engine tool provides the Sprite capabilities that EZGUI 4.0 Pro does ? You would have to purchase a high end Graphic engine to do this (and more expensive than the complete EZGUI package), but with EZGUI its part of the package. EZGUI is more than just a Visual Designer and for this special price you are getting a lot for your money.

What are Sprites ?

Sprites - An Overview

Sprites are graphic objects which can float above a Canvas control. They are merged with the Canvas controls background dynamically. Sprites can be moved. They can be hidden or shown. They can be flipped (vertically or horizontally).

Sprites are simply a rectangular image buffer which can be drawn on (and later displayed on top of a Canvas control). They can have multiple frames (for animating). Sprites can also have a transparent color defined, so only certain pixels will be displayed. This is how sprites can appear to be non-rectangular.

Sprites can be designed (defined) in one of two ways. You can use the EZ_DefSpriteByPict command to create a sprite from an existing EZGUI Picture (bitmap). You can also create a sprite by creating an empty sprite image buffer using EZ_DefSprite and then draw the sprite via code using the EZ_StartSpriteDraw and EZ_EndSpriteDraw commands. You can use any of the EZGUI DC (device context) graphic commands to draw on a sprite buffer.

Sprites have to be assigned to a specific Canvas control before they can be displayed. By default the are hidden when first assigned to a Canvas control. You must show the sprite before it is visible.

Sprites also have the unique ability to be AlphaBlended onto a Canvas control. AlphaBlending is where the sprite is given an effect value of 1 to 100 (percent) and EZGUI will blend the sprites pixel colors with anything behind it (including the Canvas and other sprites). It could be compared to looking through a colored piece of glass. You can see what is behind it, but the background image filters through the colored glass (colors are blended). It is the same with sprites.

While sprites are often used for software which are games, there are many practical uses of sprites for other types of software. Sprites can be used for overlays (ie. a map with multiple overlays on top). They can be used for animations, presentations, etc.

Screenshot of Sprites:





Screenshot of Sprites AlphaBlended:

[Chris Boss]

DIB's, DIB's, DIB's ! Whats a DIB ?

A DIB is a "Device Independent Bitmap", which in simple terms is a Bitmap where you define the actual pixel mode (16 bit, 24 bit, 32 bit) and you have direct access to the pixel data.

Unlike using the GET/SET Bits style of coding using the API, where you have to move blocks of pixel data to a buffer, modify it and then move it back, DIB's allow you to access the pixel data directly with no need to move the data. This is much faster.

EZGUI's Canvas control supports DIB buffers (bitmaps) (and it also supports double DIB buffers) which makes it great for creating graphics which require fast, direct pixel manipulation.

One example is an image filter.

Here are some screenshots of a very simple program which can load a Bitmap and then apply different image filters to it. The original image is kept in one DIB buffer and to filter the image, it is copied to the other DIB buffer and then quikcly modified. The program can apply the filter almost instantaneously (in a split second).

Screenshots:
















Heres the source code for this application:

' *************************************************************************************
'                    Portions: Copyright Christoper R. Boss, 2003 to 2006
'                                    All Rights Reserved !
'                 Registered EZGUI 4.0 users may use this code Royalty Free !
' *************************************************************************************
#COMPILE EXE
#DIM ALL
' --------------------
#INCLUDE "..\includes\ezgui40.inc"
' --------------------
DECLARE SUB Form1_Display(BYVAL Parent$)
DECLARE SUB Form1_Design()
DECLARE SUB Form1_Events(CID&, CMsg&, CVal&, Cancel&)
DECLARE SUB FORM1_FILE_Select()
DECLARE SUB FORM1_OPENBITMAP_Select()
DECLARE SUB FORM1_EXIT_Select()
DECLARE SUB UseFilterOnBitmap(BYVAL Mode&)
GLOBAL FORM1_hMenu0&
GLOBAL FORM1_hMenu1&
' --------------------
#INCLUDE "..\includes\ezwmain.inc"
' --------------------
SUB EZ_Main(VerNum&)
    Form1_Display ""
END SUB
SUB EZ_DesignWindow(FormName$)
    SELECT CASE FormName$
        CASE "FORM1"
            Form1_Design
        CASE ELSE
    END SELECT
END SUB
SUB EZ_Events(FormName$, CID&, CMsg&, CVal&, Cancel&)
    SELECT CASE FormName$
        CASE "FORM1"
            Form1_Events CID&, CMsg&, CVal&, Cancel&
        CASE ELSE
    END SELECT
END SUB
SUB Form1_Display(BYVAL Parent$)
    FORM1_hMenu0&=EZ_DefMainMenu( 500, "&File", "")
    EZ_Color -1, -1
    EZ_Form "FORM1", Parent$, "Compress Bitmaps", 0, 0, 80, 28, "C_"
END SUB
SUB Form1_Design()
    FORM1_hMenu1&=EZ_DefSubMenu( 505, "&Select Bitmap File", "")
    EZ_SetSubMenu FORM1_hMenu0& , 500, FORM1_hMenu1&
    EZ_AddMenuItem FORM1_hMenu1&, 510, 0, "-", ""
    EZ_AddMenuItem FORM1_hMenu1&, 511, 0, "Show Red Only", ""
    EZ_AddMenuItem FORM1_hMenu1&, 512, 0, "Show Blue Only", ""
    EZ_AddMenuItem FORM1_hMenu1&, 513, 0, "Show Green Only", ""
    EZ_AddMenuItem FORM1_hMenu1&, 514, 0, "Limit Color Planes to High 4 Bits", ""
    EZ_AddMenuItem FORM1_hMenu1&, 515, 0, "Limit Color Planes to Low 4 bits", ""
    EZ_AddMenuItem FORM1_hMenu1&, 516, 0, "Show Blue Only 14 Bit", ""
    EZ_AddMenuItem FORM1_hMenu1&, 517, 0, "Show Green Only 14 Bit", ""
    EZ_AddMenuItem FORM1_hMenu1&, 518, 0, "Show Gray Scale 7 Bit", ""
    EZ_AddMenuItem FORM1_hMenu1&, 519, 0, "Show Red Tinted", ""
    EZ_AddMenuItem FORM1_hMenu1&, 520, 0, "Show Green Tinted", ""
    EZ_AddMenuItem FORM1_hMenu1&, 521, 0, "Show Blue Tinted", ""
    EZ_AddMenuItem FORM1_hMenu1&, 528, 0, "Display Original", ""
    EZ_AddMenuItem FORM1_hMenu1&, 530, 0, "E&xit", ""
    EZ_Color 0, 15
    EZ_UseFont -1
    EZ_UseFont -1
    EZ_Canvas 100, 0, 0, 80, 28, "+{DIB}{DBUF}"
END SUB
SUB Form1_Events(CID&, CMsg&, CVal&, Cancel&)
    SELECT CASE CID&
        CASE %EZ_Window
            IF CMsg&=%EZ_Close THEN
            END IF
        CASE 500     ' &File
            IF CMsg&=%EZ_Click THEN FORM1_FILE_Select
        CASE 505     ' &Select Bitmap File
            IF CMsg&=%EZ_Click THEN FORM1_OPENBITMAP_Select
        CASE 510     ' -
        CASE 530     ' E&xit
            IF CMsg&=%EZ_Click THEN FORM1_EXIT_Select
        CASE  100
        CASE 511 TO 528
            IF CMsg&=%EZ_CLick THEN
                UseFilterOnBitmap CID&-510
            END IF
        CASE ELSE
    END SELECT
END SUB
SUB FORM1_FILE_Select()
END SUB
SUB FORM1_OPENBITMAP_Select()
    LOCAL F$, P$, CW&, CH&, W&, H&, AW!, AH!
    EZ_Color -1,-1
    F$=EZ_OpenFile("Form1","Select Bitmap :", "", "Bitmaps (*.bmp))|*.bmp|", "S")
    IF F$<>"" THEN
        P$=EZ_LoadPicture(F$)
        EZ_GetPictureSize P$,  W&,   H&
        ' convert to character units and resize canvas control
        AW!=EZ_ScaleToCharSize(W&, "PX")
        AH!=EZ_ScaleToCharSize(H&, "PY")
        EZ_ResizeC "Form1", 100, (80-AW!),0, AW!, AH!
        EZ_GetCanvasSize "Form1", 100, CW&, CH&
        ' draw picture on canvas
        EZ_StartDraw "Form1", 100, CW&, CH&, ""
            EZ_CDrawPicture  0,0,  W&, H&, P$, ""
            EZ_CCopyBuffer 1,2,0
        EZ_EndDraw
        EZ_FreeImage P$
    END IF
END SUB
SUB FORM1_EXIT_Select()
    EZ_UnloadForm "Form1"
END SUB
' this is the format for 32 bit RGB pixels
TYPE EZ_RGB32
    B   AS BYTE
    G   AS BYTE
    R   AS BYTE
    Reserved AS BYTE
END TYPE
                                ' Best      Good        Low     Poor
%GreenShift       =   4&        ' 4         8           8       16
%RedShift       =     16&        ' 4         8           16      16
%BlueShift       =    16&        ' 4         8           16      32
SUB UseFilterOnBitmap(BYVAL Mode&)
    LOCAL CW&, CH&, FirstPixel&, YB&, X&,Y&,PY&, V&, VT&
    LOCAL P AS EZ_RGB32 PTR, BitMask?, BitMul?
    EZ_GetCanvasSize "Form1", 100, CW&, CH&
    EZ_StartDraw "Form1", 100, CW&, CH&, ""
    ' copt buffer 2 to buffer 1 to get original to work with
    EZ_CCopyBuffer 2,1,0
    FirstPixel& = EZ_StartDrawByPtr("Form1", 100, 0)
    IF FirstPixel&<>0 THEN
        YB&=CW&*4
        FOR Y&=0 TO (CH&-1)
            PY&=FirstPixel&+(Y&*YB&)
            FOR X&=0 TO (CW&-1)
                P=PY&+(X&*4)
                BitMask?=240
                BitMul?=1
                SELECT CASE Mode&
                    CASE 1
                        @P.R=(@P.R AND BitMask?)*BitMul?
                        @P.B=0
                        @P.G=0
                    CASE 2
                        @P.B=(@P.B AND BitMask?)*BitMul?
                        @P.G=0
                        @P.R=0
                    CASE 3
                        @P.G=(@P.G AND BitMask?)*BitMul?
                        @P.R=0
                        @P.B=0
                    CASE 4
                        ' high 4 bits
                        @[email protected] AND 240
                        @[email protected] AND 240
                        @[email protected] AND 240
                    CASE 5
                        ' low 4 bits
                        @P.R=((@P.R AND 15)*16)
                        @P.G=((@P.G AND 15)*16)
                        @P.B=((@P.B AND 15)*16)
                    CASE 6
                        ' 18 bit color shows little or no loss
                        @P.R=0
                        @P.G=0
                        @P.B=(@P.B\%BlueShift)*%BlueShift
                    CASE 7
                        ' 18 bit color shows little or no loss
                        @P.R=0
                        @P.G=(@P.G\%GreenShift)*%GreenShift
                        @P.B=0
                    CASE 8
                        ' GrayScale
                        V&=(@[email protected][email protected][email protected][email protected][email protected])\6
                        ' V&=(V&\2)*2
                        @P.R=V&
                        @P.G=V&
                        @P.B=V&
                    CASE 9
                        ' Red Tinted
                        V&=(@[email protected][email protected])\3
                        @P.G=V&
                        @P.B=V&
                        V&=V&+164:IF V&>255 THEN V&=255
                        @P.R=V&
                    CASE 11
                        ' Blue Tinted
                        V&=(@[email protected][email protected])\3
                        @P.G=V&
                        @P.R=V&
                        V&=V&+128:IF V&>255 THEN V&=255
                        @P.B=V&
                    CASE 10
                        ' Green Tinted
                        V&=(@[email protected][email protected])\3
                        @P.R=V&
                        @P.B=V&
                        V&=V&+80:IF V&>255 THEN V&=255
                        @P.G=V&
                    CASE ELSE
                END SELECT
            NEXT X&
        NEXT Y&
    END IF
    EZ_EndDrawByPtr
    EZ_EndDraw
END SUB

[Chris Boss]

It would be good to note here, that there are different levels of Graphics programmers may have an interest in using.

EZGUI was not designed to be a "leading edge" graphic engine. There are a lot of companies that do "only" graphics and have tools which push Windows graphics to its limits. Often these tools are used in developing high end graphic editors, etc. (aka. Photoshop like tools).

EZGUI's graphic engine is a "compliment" to its main purpose as a GUI tool and Designer. I have always stated this.

For example, you don't usually find things like advanced listview control support, richedit support, search functions, etc in a Graphic only tool. EZGUI is a GUI engine for building complex applications, especially for business application development. Graphic only tools don't usually come with a Visual Designer and Code Generator.

The graphics features found in EZGUI compliments the needs of the average Windows developer who writes software for a variety of areas.

The value in EZGUI's graphic engine is based on the fact that it is part of an integrated package, not as a standalone graphic engine.

I also should note, that the price for "leading edge" graphic only tools tend be quite high (They usually are worth it though) and are in a totally different catagory than EZGUI.

EZGUI is a GUI engine (forms/controls/etc) with a print engine, visual designer/code generator which also happens to have an advanced graphic engine integrated into it, tailored to the average needs of Windows developers.

Please do not confuse my comments about EZGUI as a direct comparison with high end tools like GDImage which are in a totally different catagory than EZGUI. Such tools serve a different purpose than EZGUI.

[Chris Boss]

Areas where EZGUI excels:

(1) Support for Legacy systems.

A good number of software developers tend to lean towards the "leading edge" operating systems (ie. XP, Vista) leaving behind all users of previous operating systems.

Is there any benefit in supporting legacy operating systems ?

Yes there is.

In a business environment there are often a number of older PC's which have plenty of life left in them, which could end up simply being thrown away just because newer software won't run on them.

Think of the value of being able to develop software (either inhouse or for customers) which can still run on say Windows 95/98 or ME. Money wasted on phasing out the older computers, simply because they can't run newer software, is saved and can be better spent elsewhere (not to forget the benefits to the environment in not throwing away perfectly good computers).

Your target customer base is greater because you don't have to leave out those who have no desire to upgrade their computer unneccesarily.

EZGUI was designed specifically to be backward compatible with older operating systems (Windows 95 w/ IE 5.0 installed). It doesn't mean though that you don't get the benefit of newer operating systems. EZGUI checks to see what operating system is running and makes certain features available on the new OS. It does this though by dynamically loading some operating system DLL's and calling some API's by address, rather than explicitly (declares). If the feature is not available on a particular operating system, EZGUI will use the next best thing or if not possible simply ignore your request.

This means you can use EZGUI to build apps that take advantage of a number of the later features of Windows (if you plan to only support more current OS's) or you can target all the 32 bit Windows operating systems.

Also EZGUI uses a number of proprietary tricks to offers features, not normally found on legacy systems. For example the Sprite engine can run on any version of Windows and no DirectX, OpenGL or GDI+ is required.

Also since EZGUI provides support for a number of advanced GUI features, such as 3D and 2D colored buttons, Shaped Forms (not rectangular Forms based on a bitmap and region), alphablending sprites, etc. you can create apps that look like they were designed for a more current operating system, but look great even on Windows 95.

(2) Ease of coding complex tasks.

EZGUI users often repeat the same comment about how much easier it is to do a number of things with EZGUI compared to doing it with the API. At times EZGUI can do a complex task with a single line of code, that would otherwise require a dozen or more lines of complex API code.

For example, EZGUI can create a Toolbar, with a selected bitmap (builtin ones), all the buttons and text with just one line of code.

The EZGUI EZ_Toolbar command contains 374 lines code in it, not counting the calls it makes to other internal routines within the runtime (which could add up to dozens more lines of code, maybe more).

Another example is the EZ_StartDrag command.

This command impliments drag icons and autoscrolling for both the listview and treeview controls. This one command accesses over 500 lines of code.

Such commands are more than low level wrappers over a few API's, but are extensive high level GUI commands.

This is where EZGUI saves you a significant amount of time. When it comes to many complex tasks, EZGUI makes it simple and fast.

(3) Features not found in other Designers, such as Layers

One of the most used features in EZGUI, which AFAIK is not found in any other Designer is its Layer engine. Where other design tools require you to use a unique child form for each tab on a Tab control, EZGUI uses the much easier layer system to accomplish this. In the Designer, you can switch layers to put controls on different layers, one for each tab of the tab control and you can visually see how your tab control will really look. You only need one form (the parent form of the tab control).

Layers are an easier way to work with the Tab control visually.

Layers don't require a tab control either! They are separate from the control itself and can be used for all sorts of stuff.

Layers can also be combined. You can show layer 1 and 2 together, layer 4 and 8 together, etc. You can even group layers so they act a separate groups (ie. layers 1 to 5 used for Tab 1, layers 6 to 10 used for tab 2, layers 11 to 15 used for something else). In fact, EZGUI supports up to 100 layers in the Visual Designer.

Also the ZOrder is automatically taken into consideration when working with layers. For example, you can set controls with Tab order numbers unique to their layer. When the designer and code generator handle layers they order the controls based on their layer first and then by their tab order number.

[Chris Boss]

This Sale ends very soon, just a few more days.

I will not be extending the sale after it is over, so act now. The price will go back to its normal $249 price.

For $99 this is a great deal. I have sold many copies of EZGUI 4.0 Pro for the normal price of $249 and it is worth the price even then.

For just $99, you be able to write applications that even seasoned API programmers would find difficult. Sure there is a learning curve even with EZGUI, but it can do so many things and much more easily than when using the API.

Even VB programmers can't do many of the things that can be done with EZGUI (without having to resort to some third party custom controls).

Some areas where EZGUI's Visual Designer does some nice tricks:

(1) Working with Tab controls.

AFAIK, EZGUI is the only Designer which supports the use of Layers and it makes working with Tab controls visually easier than any other method. You don't need a separate form for each Tab. You can use one form and then simply put each tabs controls on a different layer. You can switch between layers quickly to see what each one looks like. You can even display all the layers at one time if you need to.

(2) OwnerDraw Buttons

EZGUI has built in support for ownerdraw buttons and you see them as they will look in your app. The Designer can generate 2D colored buttons, 3D colored buttons, elliptical 3D buttons and even display EZGUI macros on 3D buttons (ie. those shapes found on VCR buttons). You can also create your own Button plugins to change how the buttons look and visually work with a totally different 3D button look all your own. The plugin will then generate the proper code for you app to have your custom buttons (put it in an include).

(3) Copy and paste controls with extra features.

EZGUI provides some extra features for working with controls.
You can copy a group of controls (use CTRL Key and mouse to select) and the copy them. Now when you paste the controls you have 3 options:

- Paste Offset (at new location, but in same relation to each other)
- Paste Exact (paste in exact same position)
- Paste Cascade (paste at location, but cascade the others from first control)

Another nice feature is that you can copy controls from one form and then paste them on any other form in your application. Select the controls on one form and copy. Then select another form and then paste them on it.

You can even close the current project, load a new one and then paste the controls on the form of another project.

(4) 3D Brushes for backgrounds of controls and forms.

Most designers only allow you to work with solid colors for backgrounds.
EZGUI provides 56 builtin 3D brushes to use for form/control backgrounds. EZGUI's 3D brushes (called Patterns) are kept in a separate DLL. A template is provided to create your own pattern DLL and the designer can load a different pattern DLL. You can then use these 3D patterns for the background of any controls which will support them (some controls don't work well with 3D patterned brushes).

EZGUI's patterns are 8 x 8 pixels, which is what Windows 95/98 supports, but I would think it should be possible to use larger patterns on Windows XP and Vista. The Designer displays the patterns in about 1 32 x 32 pixel area, so 32 x 32 pixel patterns would look nice in the designer. I haven't tested this out, but I don't see why it shouldn't work. At the least though you can definitely work with 8 x 8 pixel patterns and you can do a lot with that. EZGUI uses the CreateBrushIndirect API function to load 3D brushes. The API docs say that while Win95/98/ME only support 8 x 8 brushes, Win NT/2000 and later supports larger brushes.

Because EZGUI's runtime and Designer load the brushes from a separate DLL, this makes it easy to add your own custom 3D brushes to both the runtime and the designer.

Heres the default builtin 3D brushes:



(5) Save Forms as Templates

You can forms as templates. Templates are then saved in a special folder and only certain attributes of the form are used. Templates are then displayed in the "New Form" dialog. When creating a new form, you can select a template and the new form will be layed out for you, with any controls on that template. You don't have to worry about filenames of the forms to use them. They are kept separate from regular form files (and a different extension) and you simply select them by their description.

(6) Auto generating Timer and Thread code

EZGUI provides its own TIMER and THREAD command set (it does not use PB thread commands internally, but calls the API directly) in its runtime.

The Designer allows you to define up to 2 Threads and 1 timer per form. The code is autogenerated for you so you can easily add threads and timers to your apps.

(7) Completely design your Toolbars in the Designer

Because the Designer has its own ToolBar builder dialog, you can design your toolbars visually. Simply load in the toolbar bitmap you have created using any graphic software (put the images side by side in one bitmap). The Toolbar Builder dialog allows you to define each button, its text and the image to use and other attributes. If you use Toolbars a lot in your apps, then a Toolbar builder dialog is a necessity.

[Chris Boss]

There is about 36 hours left for this sale.

Don't let it go by.

Once the sale is over, the price goes back to the regular $249.

[Chris Boss]

Sale is over!

This sale is now over!

Thank you to all who ordered.