No announcement yet.

EZGUI 4.0 Professional - Super Sale (only $99) (beat the recession)

  • Filter
  • Time
  • Show
Clear All
new posts

  • EZGUI 4.0 Professional - Super Sale (only $99) (beat the recession)

    (This sale has been extended and slightly changed)

    EZGUI 4.0 Professional
    Super Sale!

    This sale has been extended for another month (one less bundled item though)

    From January 2, 2009 until January 31, 2009 I am offering EZGUI 4.0 Professional for only $99 !

    To sweeten the offer I am also bundling one other product along with it:

    - EZGUI Utility Dialog Designer (design applications using pure DDT)

    This is the best offer I have made yet!

    This is a savings of over $162 ! (thats using the current sale price of the Utility designer)

    To order quickly use this link:

    Remember, EZGUI 4.0 Professional is not just another Visual Designer. It is a full blown GUI engine along with a Visual Front end.

    Its those extras, that make a real difference:

    - a full blown Print Engine
    - a full blown Graphics Engine
    - Animation using Sprite Engine, plus Alpha-Blending
    - a full blown OwnerDraw customization engine (with graphics to support it)
    - Custom Controls package (Turtle Graphics, Canvas control with DIB Section support and Sprites, Shape/Hot Spot control, Masked Edit control, Drag Handle control, Files Listbox control, Properties Listbox control)
    - a full blown Visual Design engine (build your own drag and drop visual designer application)

    and lots more ....

    This is not just a Visual Designer. It is a complete toolkit for all the most common needs for Windows programming.

    The beauty of all of this is that it is easy to use as well. No Windows API knowledge needed. Now this does not mean it is just a beginners tool either.

    EZGUI 4.0 Pro does more advanced tasks than probably most PB programmers ever do already. Unless you are one of the few very advanced API programmers, EZGUI probably does a number of advanced things you have never tried before (or can't figure out yet).

    If you want an edge in software development, seriously consider EZGUI 4.0 Pro.

    EZGUI can do things like:

    - Customize the Common Dialogs (add child forms with controls, change the buttons to 3D, process events)
    - Impliment drag icons for the listview and treeview controls with just a few lines of code
    - convert Forms (dialogs) to transparent (layered) Windows on Windows XP and Vista
    - Build extremely advanced GUI's
    - Create Comboboxes (ownerdraw), which can display Font lists (each item a different font) or Color lists (each item with a different color box).
    - Display multiple styles of 2D and 3D colored Buttons (built into Designer as well)
    - Easily create Rebars and Pager controls and place forms on them
    - Customize Toolbars, including the background, tooltips
    - Customize the look and style of toolstips for controls like listview, toolbar, treeview, trackbar

    Now I can't say enough about the new Sprite Engine. Move non-rectangular objects (images) around the Canvas control. Flip them vertically or horizontally, anti-alias the edges, animated using multiple frames, alphablend them to the background and other sprites

    What Visual Designer can do all of this ?

    Now if you are really into building graphic orientated applications, EZGUI is for you and it does not require things like DirectX, GDI+, OpenGL. It uses the GDI, DIB Sections and EZGUI's own proprietary Sprite engine. The graphics will work even on Windows 95 (how many graphics packages can offer these features and still run on Windows 95).

    EZGUI's command set is extensive covering nearly ever aspect of Windows programming most people will ever need.

    In the rare instance you need to do something EZGUI does not provide, EZGUI is designed so you can easily integrate API calls into it, even giving you access to a number of its internal engines (ie. you can hook into its internal window procedure for forms).

    This is an offer you won't see often and the price is right.

    Take advantage if this amazing offer now.

    Got questions before you buy ?

    Email me any questions you may have and I will try to answer them in detail to your satisfaction.

    [email protected]


    [email protected]

    Lastly, get some of the best tech support around when you buy the software. Ask my customers about the quality of support I give. If I can create a product like EZGUI, you can have confidence in my knowledge of the Windows API and Windows programming. Of course I can't know it all, but my knowledge is extensive enough to help you solve most problems you may face.
    Last edited by Chris Boss; 2 Jan 2009, 11:00 AM.
    Chris Boss
    Computer Workshop
    Developer of "EZGUI"

  • #2
    If you've ever considered EZGUI, you don't want to pass this up.

    We've used Chris' product for several years and are very pleased with it. The latest (version 4) handles just about everything you can imagine. Many of the questions posted on the PB forums involving complex manipulation of some of the common controls, for example, are resolved in EZGUI with one or two lines of code.

    EZGUI and PB make a powerful combination. EZGUI 4 by itself is a great bargain at $99. I'm not sure what Chris is thinking by including the DDT designer and Turtle Graphic control in this price, but it just sweetens the deal even more.

    As with any product, there is a learning curve. Once you're up to speed with EZGUI, there's no looking back.

    (Disclaimer: I don't work for Chris and he's not paying me to write this. I use EZGUI almost every week and would suffer greatly without it.)
    <strong>Billing clients for your freelance work?</strong> Try <a href="">Minute-2-Minute</a>, the project management, timing, and billing system. Perfect for programmers who charge by the hour. FREE 45-day trial.


    • #3
      Integration is the key!

      One of the advantages of EZGUI 4.0 Pro is that it is a complete package with many integrated parts.

      Building the front end (the forms/controls) of your application is only the first part of the process. Once you have the visual part of your software created, you now need to make it do things. Thats where programming using the Windows API can get complicated.

      EZGUI goes beyond this, by providing a number of engines to support your GUI. I designed EZGUI by simply asking myself, "what do most Windows programmers need to be able to do in their applications ?". I then added those features to EZGUI's runtime engine.

      For example, most applications need to be able to print to the printer, so I added a complete print engine that is integrated into the GUI engine.

      Each control supported has well balanced set of support commands to do the most common tasks. Here is where EZGUI excels. I didn't simply just start writing wrappers for easy to use messages. What I did was ask myself, "what common tasks would most programmers need to do with this control ?". In some instances, a wrapper to a simple message was all that was needed, but in many instances some very complex API routines had to be written. I didn't add routines, simply to bloat the runtime with a huge number of easy to write, but not often used commands. I added commands which are very useful and actually needed.

      One example, is the drag and drop engine for the listview and treeview controls. The ability to drag items (an icon actually, your code does the moving of items). The drag icon coding it quite complex and not easy to write. Yet, since I felt it was a necessary feature for these controls, I added this to EZGUI's runtime engine.

      Another example, is multimedia. MCI was the best choice here since it was easy to impliment and yet quite versatile. I wrote a custom MCI control. Why not just create simple wrappers for the MCI command API calls ? I felt that the MCI command set was a little time consuming to learn (so something easier was needed) and some may get find it confusing how to handle the client window for things like video.

      The solution: Write a custom control which handles much of the hard stuff for you. The MCI custom control handles all the client window tasks for you so displaying video is easy. The control also has its own high level EZ (easy) MCI command set which is easier to use than pure MCI. You don't have to mess with an alias name for objects, etc. You simply pass commands like:

      "EZOPENMOVIE |c:\somepath\somemovie.avi|"

      The most common video, audio, wave and midi tasks are handle easily.

      Another example of the design considerations that went into EZGUI 4.0 Pro are the custom controls.

      Rather than create a bunch of high level interface controls to try to emulate features in other applications, such as Microsoft apps, I chose a more low level and versatile direction. Rather than simply add a bunch of custom controls with limited use, I added controls which would allow you to expand your GUI's into all sorts of directions. The choices are unlimited.

      I did this in two ways:

      First, for the common interface controls, rather than create a bunch of custom controls, I allow you to customize many existing controls any way you like. For example, EZGUI has a complete ownerdraw engine for customizing menus, buttons, comboboxes, listboxs, tab control and listview. There is a simplified ownerdraw command set to get started and an advanced lowlevel command set to accomplish unlimited choices. I also added a subclassing engine, which makes it easier to modify how controls work, how they draw their backgrounds, etc. There is a keyboard preprocessing engine which allows you to preprocess keys before a control gets them. And there is a complete graphics engine for any drawing you may need.

      Next, I create a number of actual custom controls. Some high level, others more low level.

      First is the Canvas control.

      This is not simply just a drawing window. It is a sophisticated graphic tool. For example, it automatically can handle double buffers in the current graphic format or in 16,24 or 32 bit DIB sections. When using DIB sections you get direct access to the pixel data. This is not the same as using GET SET pixel buffers, where you have to move the data to a buffer, modify it and then move it back. You get direct access to the pixel data via pointers and you don't have to waste time moving data back and forth. This increases the speed of drawing significantly.

      Not only is the Canvas supported by an complete graphics engine, but it has its own Sprite engine which can handle moving around non-rectangular objects (called Sprites) around the Canvas background. The Canvas control integerates your background image with the sprites on it for you, but they are separate in memory. Sprites can also be alphablended to the background and other sprites. They can also be animated using frames.

      What Visual Designer has anything like this ? (graphics)

      You would have to buy an advanced separate graphics package to get many of these features, but they are integerated into EZGUI.

      Some custom controls are quite simple really, but yet they are very useful.

      EZGUI adds the shape/hot spot control. The shapes are simple, but the control automatically handles the region generation for the shapes for you. To be truly non-rectangular a control must use a region. The control also can act as a hotspot control, which is basically a non-visible control (background shows through), which accepts mouse clicks. You can overlay a number of hotspot controls over a picture control to create a truly interactive image.

      EZGUI provides a Turtle Graphics control with its own drawing macro language. The advantage of this is that the image is not a Bitmap, but is a vector image. Vector images can easily be scaled. They produce very tiny data files (simply write the macro string to a text file). Vector drawing is a powerful tool when used correctly.

      On the surface these two controls seem simple, but they allow you to do all sorts of advanced graphics and to build your own unique GUI's.

      Another, low level, yet powerful control and engine is the drag handle control (and support drag drop engine). EZGUI not only provides a way to subclass any control you create and add drag and drop (size and move) features to them (via its subclassing/dragdrop engine), but it even provides a unique drag handle control which can be used to impliment real drag handles. The control automatically displays all eight drag handles, handles the icon changes over each drag handle and also can have a buddy control attached to it. You drag the drag handles and the control automatically sizes or moves its buddy control. You can define the size of the drag handles and their colors.

      WYSIWYG style applications are quite possible with EZGUI, because of its drag and drop visual designer engines.

      What other PB tool offers you this ?

      EZGUI also provides a number of advanced features which allow you to build some very complex applications.

      One example is the Thread engine.

      Oh, I can do that with PB Thread commands you say.

      This is different. EZGUI goes one step further.

      When using Threads two important factors need to be considered.

      One, is dealing with the GUI. EZGUI provides a mechanism so you can keep GUI commands out of your thread code and keep all GUI commands, where they belong in the primary thread (its a long explanation of why this is so).

      Second, there needs to be some way to control the syncronization between threads. I chose Critical sections. EZGUI uses critical sections to syncronize all threads and it provides easy to use critical section commands for you to add such support to your thread code (especially necessary with multiple threads).

      Threads can easily be abused, so EZGUI provides mechanisms to keep them in check and to work well together.

      The point is that EZGUI is more than a Visual Designer/Code Generator.

      It is a full blown GUI engine which does all the dirty work for you, so you can concentrate on writing your applications.
      Chris Boss
      Computer Workshop
      Developer of "EZGUI"


      • #4
        EZGUI 4.0 Pro is not for everyone!

        EZGUI 4.0 Pro is not for everyone!

        You might find that a strange statement, but it is true.

        I did not design EZGUI for SDK purists or for those who prefer 100% source code. It is true that one can learn the Windows API given enough time. If that is want one prefers, then simply put "look at another development tool, don't consider EZGUI"

        Then who was EZGUI designed for ?

        I wrote custom software for businesses for a number of years and I know what goes into developing a full blown application. The two considerations I always had to deal with when developing software were:

        (1) Can I actually accomplish what I want with the tools I use ? Meaning, can I actually impliment the concept. No matter how good ones ideas are about what they "want" their software to do, it is of no value if you can not actually impliment it.

        (2) How quickly can I develop the software ? There is a saying, "time is money" and this is true. Professional software developers know one thing, that they have only a finite amount of time to develop the software. It is of no value to develop software using low level tools, if takes you far too long to do it. It costs something to develop software and someone has to pay for it. The amount of time it takes to develop software is critical to the process. Now if you write software as a hobby or in your spare time for fun, then this means nothing to you. But if you write software for a living, then you understand what I mean.

        All the arguments about whether one development tool is better than another or whether software should be developed one way or another are simply mute.

        For those who write software for a living (or a business) it all comes down to one thing:


        This is the type of person I wrote EZGUI for!

        Someone who considers productivity to be the key factor in the tools they choose.

        EZGUI gives you the power of Windows and the API, without spending more time than is necessary.

        For the same reason Basic programmers choose Basic over other languages (productivity and ease of use), EZGUI provides the same thing compared to using the Windows API directly.

        You do not give up the power of the Windows API when using EZGUI.

        EZGUI simply speeds up the process of developing applications.

        Like I said, EZGUI is not for everyone.

        It was designed for programmers who need to be productive.
        Who need solutions quickly.
        Who need advanced features now, rather than take months to learn how to do it with the API.

        The real test of a programming tool, is this:

        Look at the customers who use the tool and then ask:

        How many commercial applications have they developed recently and what is their quality ?

        When I see a customer developing one application after another (or one version after another of the same product) using EZGUI, then I feel I have accomplished my goal.

        To make my customers productive.

        There are EZGUI users who have produced not just one application using it, but application after application. They are productive! They keep producing.

        There is a reason I call my tool "EZGUI 4.0 Professional" :

        I expect a professional programmer to be able to produce dozens of professional quality applications with it, quickly.

        If that is your goal also, please seriously consider EZGUI 4.0 Pro.
        Chris Boss
        Computer Workshop
        Developer of "EZGUI"


        • #5
          To quote Frank Kelly:

          Many of the questions posted on the PB forums involving complex manipulation of some of the common controls, for example, are resolved in EZGUI with one or two lines of code.
          This is from a customer who uses EZGUI.

          The bottom line is being productive.

          EZGUI users chuckle, when they see posts on the forums about trying to accomplish some complex task using the API, when they know they can do it with EZGUI using one or two lines of EZGUI code.

          For example, one discussion in the forums I followed dealt with windowless richedit controls and the ability to draw richedit text into any window DC. The API docs suggest using the windowless richedit, which requires COM.

          EZGUI already does this and without COM (thats why I couldn't post any code for that discussion since it was part of my software product, though I did reveal that it is done using the EM_FORMATRANGE message). It is done easily by EZGUI users.

          This is my point.

          EZGUI provides numerous advanced features that many experienced PB API programmers haven't even figured out how to do yet.

          EZGUI is in its fourth generation now and I have attempted to push the limits of the API in every new version. It is an advanced tool.

          For example, you won't find any simple API code anywhere on the forums which can draw Sprites and Alphablend them and Anti-Alias them at high speed (for a software only solution). Thats not something you learn in a few days or weeks by studying the API. There is no simple API wrapper one can write for that.

          EZGUI is at times viewed by some as some kind of beginners shortcut to the API. Its is not. It is a professional level tool which pushes windows to its limits in an application. EZGUI users can do things in their apps that many Windows programmers can't even imagine doing in their apps, using the API.
          Chris Boss
          Computer Workshop
          Developer of "EZGUI"


          • #6
            High Level and Low Level

            EZGUI 4.0 Professional is quite unique in that it is both a high level and a low level tool.

            First, lets look at some of its high level features.

            EZGUI provides a number of commands for displaying the Common Dialogs.

            It goes a step further in providing mechanisms to gain more control of these dialogs. When EZGUI displays the dialog, it also automatically creates an internal hook procedure for all of the common dialogs (even the browse folder dialog). It then sets up an even processing engine for the dialog, so the controls on the dialog send actual events to your application.

            EZGUI doesn't use handles for dialogs (forms). It allows you to define them all using a name (a string) (ie. "Form1"). EZGUI predefines a name for all of the common dialogs.

            Here are the names

            "{OPENDLG}" - Open File Dialog (Standard Type)
            "{SAVEDLG}" - Save File Dialog (Standard Type)
            "{OPENDLGX}" - Open File Dialog (Explorer Type)
            "{SAVEDLGX}" - Save File Dialog (Explorer Type)
            "{COLORDLG}" - Color Dialog
            "{FONTDLG}" - Font Dialog
            "{PRINTDLG}" - Printer Dialog
            "{PAGEDLG}" - Page Setup Dialog
            "{FINDDLG}" - Find/Replace Text Dialog
            "{BROWSEDLG}" - Browse Folder Dialog

            Other EZGUI Dialogs which are not common dialogs, but EZGUI's own special dialogs.

            "{MSGBOX}" - Extended Message Box
            "{ABORTDLG}" - Printer Abort Dialog

            The even engine in the EZGUI runtime generates actual events for these Dialogs and their controls, so you can intercept them and add features to the dialogs.

            This makes it easier to modify the dialogs, add child forms (with controls), change the dialogs position, etc.

            EZGUI even allows you to convert all the buttons on a common dialog to 3D ownerdraw buttons, so you can change the look and style to match the rest of your application.

            Much of EZGUI's high level code is in its Event engine. EZGUI does a significant amount of message processing for you in the background. For example, EZGUI knows whether a Form is a MDI Parent Form, a MDI Child Form or a regular Form and automatically handles the proper message loop processing for you. EZGUI does not use the Windows Modal message loop for its own Modal Forms (the common dialogs and messagebox do use the windows modal message loop). Instead it impliments its own Modal message loop. This gives access to processing things in the message loop of modal forms, that normally is not possible with the Windows modal message loop.

            Some controls require a lot more setup code than do others and EZGUI adds high level control of this. One example is the Toolbar control. EZGUI has one command which can basically set up nearly the entire toolbar in one line of code, even defining all the buttons.

            Obviously stuff like EZGUI's custom controls, Sprite Engine, Visual Design engine, subclassing engine are very high level.

            Now as far as low level, EZGUI provides all sorts of low level commands for many different tasks. For example, EZGUI provides a high level simplified ownerdraw command set, it also provides a set of very low level commands for drawing things exactly the way you want them.

            While there are a number of high level features in the Canvas control, you can also do some amazing low level stuff using the DIB section buffers. It is easy to impliment low level image filters, using the DIB section engine in EZGUI's canvas control.

            Whether you need high level features to develop apps quickly or lwo level features to push your apps to the limit writing your own custom code, EZGUI has it.

            The runtime itself has over 600 commands (subs/functions), but the actual features goes way beyond that. Why ?

            A number of commands work with more than one control type (ie. search functions) so you are getting much, much more. A few commands (ie. EZ_SetAttr and EZ_GetAttr wrap over 150 different API messages) can do many different functions, like the EZ_DCDraw command, which actually wraps a number of different drawing features into one command.

            Add to this, the custom controls and many engines in EZGUI (which do things for you automatically), the feature set is far beyond that of most tools.

            Chris Boss
            Computer Workshop
            Developer of "EZGUI"


            • #7
              First, before I go on, let me say that I have the utmost respect for the other third party Visual Design tools for Powerbasic.

              Edwins PwrDev is an amazing tool, with features not found in any other Designer, even EZGUI. He offers it for a low price, for what it does, and every PB'er should take a close look at it.

              Pauls FireFly is also an amazing product, priced much lower than its worth (even at its $99 price) and for those who want a VB like environment, great tech support, ActiveX support, it is also worth a closer look.

              There are others not mentioned as well.

              I would like to comment on one viewpoint about programming with PB, that I disagree with.

              It is the viewpoint that the only "right way" to program Windows applications, is to use the Windows API directly and that any other method of programming is seriously flawed.

              Some SDK purists, have even spoken poorly of PowerBasic's DDT command set as if it was somehow flawed, because it is not the direct API.

              If this viewpoint were really correct, Microsoft would still be writing programs using the old style C, rather than C++ or C#. The whole reason MS likely implimented MFC (Microsoft Foundation classes) for C, was that programming using pure API code was very time consuming.

              Visual basic, one of the most popular programming languages ever, is not a pure API coding style. It is a high level framework on top of the API.

              The point is, that one does not put their business at risk somehow by using tools written by other companies. You will not become the laughing stock of all programmers.

              Even some of the best and most popular software today, uses components created by other companies (than its developer). The use of ActiveX (OCX) controls, DLL based controls and DLL based libaries is not only acceptable, but it is likely done by most of the respected software companies.

              Now this does not mean that one should not use the API directly. If a programmer is adept at using the API and more power too them. They should be using tools that generate pure API code. This is why third party tools which cater to those kind of programmers, should be supported.

              I will not say that EZGUI is "better" than all other Visual Design tools.
              Simply put, each tool has its strengths and weaknesses. Each tool appeals to a different style of programmer. You have to determine what your particular needs are before purchasing a tool.

              The information I post here about EZGUI, is to allow people to be informed before purchasing. It is not a matter of "this or that tool". Some programmers buy them all (a number of EZGUI users have multiple tools). Some prefer one over the other. Purchase based on your needs. I will be the first to tell someone not to buy EZGUI, if I think that it will not satisfy their needs.

              EZGUI's approach to programming Windows programs is different. This does not mean it is the only way or the only right way. It is simply a different approach that has its merits. If the approach appeals to you, will solve your programming problems and it offers benefits that you require, than please consider it. If it does not, please seriously consider some of the other Visual Design tools for PB. Definitely take a close look at PB Forms first, since it has the most support from Powerbasic and is used by a significant number of PB'ers. Also consider FireFly or PwrDev or even my own DDT Designer.

              Just do not limit what you can accomplish, by believing nothing but the API is acceptable. If you do, you'll miss out on some great tools, including GDImage, EGrid, MLG, SIGridm RMChart and so on.
              Chris Boss
              Computer Workshop
              Developer of "EZGUI"


              • #8
                Unique to EZGUI

                Let me discuss some of the features which are unique to EZGUI 4.0 Professional ( as a Visual Designer/GUI engine tool).


                The EZGUI Designer has a feature called layers. While the most common use for this is for Tab controls, it is not restricted to Tab controls. It can be used for most anything you want (ie. building wizard style dialogs).

                What are layers ?

                The Designer supports up to 100 different layers!

                When you add controls to a Form, you can select what Layer they will be displayed on. Layer 0 (zero) is considered the background layer and is always displayed. Layers 1 to 99 are secondary layers.

                When the form is displayed in your app, controls on layer 0 and 1 are automatically displayed while all the others are hidden from view. The runtime provides a command EZ_DisplayLayer which allows you to show and hide layers at will. The normal way is to display a layer and then all the other layers are automatically hidden, except the one you select to display and the background layer.

                Layers allow you to work with just a single form, rather than multiple forms and to show and hide controls in groups. Especially when working with dozens of layers at a time, this is very helpful, since you don't have to have a separate form for each layer. Also it makes it easier to see how the form will actually look during development, since all the controls are on one form and you can show and hide them in the designer to see how each layer looks.

                You can also combine layers and display multiple layers together, if you want.


                The Canvas control comes with a Sprite engine. The term Sprite dates back to the old home computers of the 80's. A Sprite is a non-rectangular image which is treated separate from the background image (Canvas control) and it can be moved, shown/hidden, flipped and animated (multiple frames). If you were to do this yourself, you would have to not only find a way restore the background behind the sprite every time is was moved, but also a way to draw only certain pixels, since the image is not rectangular (actually it is rectangular, but there are transparent pixels). You also need to do this fast enough so it can run at animation speeds (at least 15 to 30 frame/sec).

                EZGUI allows you to define as many sprites as you want and then associate them with a Canvas control. EZGUI handles the merging of the sprites with the Canvas (and each other).

                EZGUI goes a step further and even provides anti-aliasing and alphablending. This is all done through EZGUI's own proprietary graphic engine and does not require DirectX, GDI+ or OpenGL.

                Now at first glance, you might think "Is EZGUI trying to be a Game engine ?".

                Well, EZGUI could be used to create games and I don't rule that out, but the primary use is for building commercial quality applications which require a more graphic orientated look and feel. You can actually create your own unique controls, using the Sprite engine and the Graphics engine. Sprites could be used for overlays on images of maps or something similiar. You could create a unique interface with sprites (yes, you can click on them). They could be used for simulations. The possibilities are endless.

                The beauty of EZGUI's Sprite and Graphic engines is they are built into EZGUI (the Designer/GUI engine). You don't have to pay a lot for other tools just to do graphics. Its built in!


                EZGUI not only provides a simplified mechanism for handling ownerdraw for menus, buttons, listboxes, comboboxes, listviews and Tab controls (the event itself), but it provides two levels for doing the actual drawing. The first is the Simplified OwnerDraw command set. What other tool offers this ? With just one line of code in an event (%EZ_OwnerDraw) you can draw a customized control or menu.

                If you need more, remember EZGUI has a Graphic engine built in, so you can also use a more level approach for drawing the controls. Doing even low level ownerdraw, is as easy as it can get using EZGUI. You don't have to worry the condition of a DC, restoring DC's to their original state or selecting objects in and out of a DC. EZGUI handles all the mundane stuff for you. You simply draw using easy to use graphic commands.

                Drag and Drop - Visual Design engine:

                EZGUI already has a subclassing engine, but it goes a step further. EZGUI impliments a drag and drop (or Visual Designer) engine, via the subclass engine. You can subclass any control you create, even third party controls (if created using the EZ_ControlEX function which is similiar to CreateWindowEx). They can be subclassed using the Visual Design mode. This allows you to drag the borders of the controls, drag the controls, etc. This allows you to the fancy stuff, like having two controls side by side and being able to drag their edges to change their sizes.

                EZGUI also provides a special custom control, called the Drag Handle control for displaying drag handles on controls. This allows you to build actual Visual Designer style applications. You can create real WYSIWYG style applications.

                EZGUI's own visual designer, is itself a 100% EZGUI application. I wrote the designer completely using EZGUI and no direct API calls. The runtime handles all the tough stuff.

                Non-Rectagular Forms (using Regions):

                EZGUI provides a high speed command for generating a region on the fly from a Bitmap (also used as the background for the form) so you can have non-rectangular Forms. This is not just some region code borrowed from the forums, but is a proprietary routine built into EZGUI which uses a very high speed technique which can handle even very complex regions quickly and on the fly. This feature is also built into the Visual Designer, so you can visually test your forms during development to see how they will actually look. There is no need to compile and run the application to see how they look.

                The more complex the image is (the more ragged the edges and lots of holes) the slower it is to convert the image to a region. When i first learned how to do this, I found the standard region generating code to be too slow for complex images, so I designed a much faster technique which can handle very complex images very fast.

                Not only can use generate a region on the fly for forms, but EZGUI can even do it for the Canvas control and a Turtle Graphics control. This means you can have non-rectangular graphic orientated controls as well.
                Chris Boss
                Computer Workshop
                Developer of "EZGUI"


                • #9
                  Why the Smart Parser ?

                  One may wonder why I chose the approach of using the Smart Parser, with the EZGUI Pro Designer.

                  Actually the concept was "customer driven"!

                  During beta testing, customers discussed how they didn't want an embeded code editor, since it would limit their choices for code editing features. They already had a favorite code editor and didn't want to change.

                  They asked me to come up with a way to allow them to be able to keep their favorite code editor.

                  The solution, was the "Smart Parser".

                  Actually, EZGUI's Smart Parser technology is quite powerful and plenty fast enough for quick development. I like to use it with the PB IDE. A number of my customers prefer to use it with JellyFish.

                  The Smart Parser also offers a number of ways to protect you from losing code, after changes to the GUI are made. For example, if you delete a control, what happens to its event code ?

                  Any visual designer that generates code, has to make a decision when a control or form is deleted, about what to do with the no longer needed code.

                  EZGUI 4.0 Pro's designer does two things.

                  One it moves the unneeded code, to a section of your source code and surrounds it with compiler directives so it won't compile. This allows you a chance to retrieve the code if something important was in it.

                  Second, the Designer makes backups of the source code , when ever it has changed it. There are three levels of backups, so you can always go back and find the code in a previous version of the source code.

                  Yes, this is a different approach, but it works well for my customers. They requested it.
                  Chris Boss
                  Computer Workshop
                  Developer of "EZGUI"


                  • #10

                    One aspect of EZGUI 4.0 Pro easily overlooked is its reliability.

                    As an experienced API programmer, one thing I have found is that when using the Windows API directly one must be very careful to make sure they read the API docs carefully. It doesn't take much to crash windows, if you are not careful. Not that it can't be done, but one must be diligent.

                    It is easy to have an error in an include file (a type, a constant) which could cause hard to find problems.

                    EZGUI gives you the benefit of not having to access the API directly, so you don't have as many problems.

                    I have gone to great lengths to research the API to make sure EZGUI works well on multiple operating systems (95 to Vista), that it knows what operating system it is running on and to make changes accordingly and to only load certain features of later operating systems dynamically (LoadLibrary) so that if an operating system DLL is not there (or the API not there), EZGUI simply ignores it or compensates.

                    In developing EZGUI I have found a number of quirks in Windows and EZGUI knows how to handle them.

                    EZGUI also does something, likely not found in many PB Visual tools and that is "parameter error checking".

                    Did you realize that I could have made EZGUI even smaller in size (the runtime) ?

                    It is amazing how small the EZGUI runtime is (about 515 KB) for all the features in it. Yet, EZGUI does a significant amount of parameter checking when you make calls to the runtime commands. EZGUI protects you from make dangerous mistakes. Instead of crashing your app, at worst EZGUI may just ignore a parameter or fix it.

                    Why ?

                    Passing bad parameters to API calls can be disastrous and difficult to debug. EZGUI protects the programmer from many such dangers when working with the API.

                    In the Windows API, things like pointers to structures or memory blocks is often used (the nature of C) and when you pass a bad parameter to them, things start going bad quickly.

                    Another consideration is that at times the API docs themselves are a bit cryptic. It is easy to misread what they say or simply not understand it.

                    I have done the extra research to fully understand the API's I used in EZGUI, so you don't have to.

                    The real question is, do my customers find EZGUI reliable ?

                    Customers have told me they rarely have found EZGUI to be the cause of any of their problems. Most EZGUI users can deal with finding the bugs in their software, since rarely do EZGUI apps crash when the user did something wrong in their code. When an app GPF's it is a little more difficult to debug.

                    Debugging in an event based program can also be difficult. EZGUI provides its own easy to use debug window (form) so you can add debug code to display data in real time. Simply print to the debug window in key areas of your program to see what is happening and when.

                    While no software tool can be foolproof, EZGUI is very reliable on multiple platforms.

                    Another consideration is the API's one chooses to use.

                    There is often more than one way to accomplish something in the Windows API. The problem is that some API's are more consistant among multiple operating systems (95 to Vista), while others are not.

                    Remember, that every new version of Windows (and service pack), changes have been made to the API.

                    Its hard to keep up with these changes to make sure your software runs as expected on all versions of Windows.

                    Now if you are the type that writes software only for the latest operating system and/or service pack then this may not be of concern to you. But if you write software which you would like to run on Windows ME, 2000, XP, Vista , even 95/98, then EZGUI can be of help.

                    The API's I used in EZGUI were specifically selected for better compatibility across operating systems.

                    Where it is absolutely necessary to be OS specific with a certain API, EZGUI tests the OS to see what version it is and then uses the appropriate code for the specific operating system.

                    The key is, you don't have to worry about all the details of each operating system. In the EZGUI help file, any commands which are unique to a later OS, it is stated what OS it will work on. The nice thing though, is the app will still run on an earlier OS, but it simply won't be able to do the specific task requested, since it is not available. OS specific API's are never called directly in EZGUI. EZGUI always loads those DLL's dynamically, gets the API's address and then calls it using call dword.

                    When using the API directly, compatibility across platforms is not easy to maintain. If you write your software on an XP system, you may not be aware of problems when it is run on 2000 or ME.

                    For businesses which write a lot of inhouse software, being able to write software which will work on legacy systems (95/98) is extremely valuable. With todays difficult economy, it makes sense to not waste any resources, including older PC's.

                    For those who write commercial software they sell, again you get a larger possible customer base if your software will run on multiple platforms. When the software sold by others only runs on XP or Vista and yours will run on 95 to Vista, who do you think can sell more software ?

                    Backward compatibility with legacy operating systems does not mean EZGUI is limited on the newer OS. EZGUI can do some amazing things on all the operating systems so you can develop state of the art software.
                    Chris Boss
                    Computer Workshop
                    Developer of "EZGUI"


                    • #11
                      The real test of a programming tool!

                      After all is said and done, what is the real test of a programming tool ?

                      Simply put, it is the quality of the software developed using that tool, by its users.

                      While many programmers are hobby programmers, most program for commercial purposes, either inhouse software for a business or software designed for sale to customers.

                      The end user of the software, does not care how the software was written (whether in VB, PB, using the API or not).

                      What they care about is the following:

                      - The speed the software executes
                      - The ease of installation (size makes a difference here)
                      - How well the software does its tasks
                      - The quality of the interface

                      One can debate the value of the Windows API or using tools which shield you from the API, but the bottom line is the end user and what they think of the software.

                      Does EZGUI 4.0 Pro "fit the bill" for a quality development tool ?

                      Definitely and here's why:

                      (1) Speed of development
                      EZGUI gets programmers productive quicker, faster than many other methods of programming. It provides an easy to use Visual Designer, but where it shines is the runtimes command set. It offers so many easy to use commands, which lets you be productive in writing code.

                      (2) Speed and small size.
                      EZGUI's main runtime is tiny in comparison to what it provides and even compared to other visual deisign tools. The 515 KB main runtime DLL is nothing compared to the VB runtimes (and OCX's) and is tiny compared to runtimes.

                      EZGUI runs quite fast, since it was written using PowerBasic. Also the code you write yourself (in PowerBasic) runs fast as well. You get the benefit of all the PB compiler offers, plus a fast, small runtime itself written in PB.

                      Huge applications can be written with EZGUI/PowerBasic which can fit on a floppy disk.

                      Another benefit of the runtime is that while initially the entire app may be larger (your EXE and the EZGUI DLL), as your app grows in size, there is a tipping point where an EZGUI app can actually be smaller in size than one written using 100% code (API). The reason is that EZGUI forces code reusability. Its modular design means that you don't have to keep writing the same style of code over and over again (ie. window procedures), since EZGUI does so much for you in the background.

                      EZGUI EXE's (your compiled code) tend to be very small, since they have less code in them, since you tend to make more calls to the runtime, rather than have to write long complex routines yourself.

                      True one could write very modular code, when using the API, but I often find many programmers tend not to do this. Often a programmer is concentrating in "how to accomplish as task", rather than how to reuse code and keep it modular to keep the size down. EZGUI forces modularity, since the runtimes do much of the work in an app and they are modular.

                      (3) Quality Interfaces.
                      One of the more important aspects of software is the quality of the interface (GUI). When using the API directly, the GUI's tend to suffer because the programmers often have a limited knowledge of the API. The more complex the controls, the less often they are used, by many programmers. Just ask yourself, how often are you using the more complex controls, like the Listview, Treeview, Rebar, Pager, RichEdit, etc ? Even if you use some of these controls, like the Listview, are you using some of the more advanced features of these controls (do you use Drag and Drop icons, imagelists, ownerdraw) ?

                      Do you use the RichEdit control ?

                      Do you handle font and paragraphing features with it?
                      Do you use the hyperlinking feature of it ?
                      Do you know how to print the contents to a printer or another window DC ?
                      Do you know how to move large blocks of data to and from the control (in the megabytes) ?

                      Do your interfaces go beyond the standard controls ?

                      How much graphics do you do in your apps ?

                      Do your apps have multimedia or advanced controls like a property listbox control ?

                      Do you use ownerdraw menus or listboxes to spice up your apps ?

                      The point is that, the test of a design tool is how complex and powerful the interfaces are that you can develop.

                      Notice some screenshots of actual apps written by EZGUI users:

                      In particular, notice the screenshots of the programs written by Fathom Systems.

                      This customer has done some amazing things with the software he has designed. The amazing thing is that the screenshots are of apps written using EZGUI 3.0.

                      Click on the link above the screenshots for Fathom Systems to see their web site. EZGUI is being used by a company that produces some very advanced and powerful products. The provide software with many of their hardware solutions, written using EZGUI.

                      Also the screenshots of the apps written by Russ Srole for Advanced Video Designs are also quite amazing. Those too were written using EZGUI 3.0.

                      Likely, what these customers are doing with EZGUI 4.0 Pro will be (and are) amazing.

                      Do your apps have such advanced interfaces ?

                      Today, software companies come and go. It is a tough economic time and companies need some advantage to stay in business.

                      If a development tool can help you produce a product in half the time, that makes a difference.

                      If a development tool allows you to add advanced features "today", rather than force you to spend months learning the API, trying to figure it out, then that can make or break a business. The "only use the API" way sounds good, but it won't make a difference if your company is not in business any more because you can't develop software fast enough or good enough.

                      A number of the more experienced longtime EZGUI users were only DOS basic programmers when they started using EZGUI. Now many of them are producing application after application for Windows and they have interfaces which even some experienced API programmers can't write yet.
                      Chris Boss
                      Computer Workshop
                      Developer of "EZGUI"


                      • #12
                        Ease of use - faster development time

                        No matter what development tools one uses, it is of benefit to learn something about the Windows API. Even EZGUI users are encouraged to learn about the API and how things work.

                        EZGUI also provides mechanisms so you can more easily integrate API code within EZGUI applications.

                        That said, as an experienced API programmer myself, learning the API is not simple and easy. It takes a long time and many mistakes are usually made along the way. It took me a few years to master many API techniques. Sure, one may learn some basics within a few weeks or months, such as window procedures, classes, message crackers, message loops, etc.

                        But the more complex stuff takes much, much longer to learn.

                        The API docs are not an easy read, often terms are geared toward C programming (have to translate most stuff from C syntax to Basic syntax), some explanations are a bit cryptic and to figure them out, one may simply have to do so with trial and error.

                        I'll be the first to admit that even EZGUI has a learning curve. All software tools do. But in comparison, EZGUI users start doing complex Windows tasks much quicker and easily than by using the API directly.

                        Also EZGUI goes far beyond the basics.

                        For example, one may in a short while learn how to display a common dialog using the API. But consider this:

                        Do you know how to add controls/child forms to a common dialog, preprocess its events, convert the buttons on the dialog to user defined 3D buttons. center the dialog, draw a different background, etc. ?

                        I would think that would take much longer to figure out.

                        One could create a RichEdit control quite easily. But do you know how to move large blocks of either text or Rich text to the control or from it, modify fonts and paragraph states of individual text in the control ? Do you know how to print the contents of a Richedit control to a printer or another window DC ? Do you know how to do hyperlinking in the control ?

                        Can you see my point ?

                        Basics are basics, but when it comes to the more complex stuff in Windows it takes time to learn hot to do these things. Sure one may say, I can learn it given enough time, but with the limited resources a business may have, can you wait that long before you can start adding such features to your software ?

                        Lastly, EZGUI is not simply just some kind of API shortcut.

                        It is an advanced GUI tool!

                        You can study the API all you want, but you won't be building your own custom controls if a few days or weeks (experienced programmers can). The basic API doesn't provide you with:

                        - Property Listbox control
                        - Drag Handle control and drag and drop engine
                        - Files Listbox control
                        - Vector based Turtle Graphics control
                        - advanced Canvas control (with 16,24 or 32 DIB support)
                        - Masked Edit control
                        - 3D Colored Buttons

                        It also doesn't provide you with a Sprite engine with alphablending (using the GDI).

                        Yet, EZGUI provides all of this!

                        In the software business there is a saying "time is money" and any tool which significantly increases development speed is worth using.
                        Last edited by Chris Boss; 27 Dec 2008, 08:13 PM.
                        Chris Boss
                        Computer Workshop
                        Developer of "EZGUI"


                        • #13
                          I would like to note that there are some EZGUI users, who IMO are quite adepted at using the Windows API directly. They are not beginner programmers or unexperienced.

                          Why then would they use EZGUI ?

                          Simply put, productivity!

                          Like anyone else, they want to develop complex software quickly, so why reinvent the wheel. They use EZGUI and then add their own custom integrated API code in a few areas where it may really make a difference.

                          It is not demeaning for an experienced programmer to use a high level tool to handle things they simply don't have to do themselves.

                          If you have ever been under a time constraint to accomplish a programming, you know what I mean.
                          Chris Boss
                          Computer Workshop
                          Developer of "EZGUI"


                          • #14
                            I would like to comment here about some comments made comparing EZGUI with FireFly.

                            First, let me say FireFly is an amazing product, which deserves to be supported. True I have a different approach to software than does Paul, but that by no means one is better than the other. For some, the pure API approach is what they want, what they need and they are experienced enough to deal with the learning curve of the API.

                            What I do find confusing, is the idea that because some choose a different approach (ie. a DLL runtime) that it is somehow ignorant and uneducated.

                            Sadly, even DDT at times has been the target of such opinions.

                            Each PB'er has different abilities, goals and resources. I think it is better to let each one make up their own mind of what approach fits their needs. It is fine to discuss, what one considers to be advantages to their product and why they think it will benefit customers. There is no need to be overly critical of the different approaches.

                            It isn't the quality of EZGUI or its specific features that are targeted by negative comments, but the concept of using a runtime to make programming easier and more productive as if that were somehow bad.

                            True people have different opinions about learning the API and how hard or easy it is. I never said one can not learn the API or shouldn't. I have simply been honest that it is not always as easy and simple as some make it out to be. I developed EZGUI originally for my own personal use just because I personally found the API challenging (and still do).

                            Now will everyone like EZGUI ?

                            Absolutely not!

                            I have customers who later feel that it was not exactly to their liking. This may simply be because it just works differently than the way personally approach programming. No two people think the same.

                            Yet, there are many happy EZGUI users who have become very proficient with it, who are willing to overlook any small quirks it may have (meaning it may just do something differently) and who have produced quality software with it.

                            There are reasons I am not able to offer a trial version of EZGUI (which I won't go into here), so I like to go into detail about the product so potential customers can make an informed choice before buying. I don't want someone to buy EZGUI if it won't help them. I'd rather see them buy FireFly or PwrDev or whatever serves them best.

                            I don't think the approach to Visual Design tools has to be "either this one or that one". There are enough PB'ers to support each unique tool, who can make informed choices about what fits them best.

                            The majority will likely choose PB Forms, since it is directly supported by PowerBasic, takes advantage of the compilers GUI's features and appears to be the most popular method for designing GUI's.

                            A percentage of PB'ers will desire something different.

                            I expect EZGUI users to always be a nitch group. EZGUI is probably too different for most PB'ers. It is also the most expensive of the PB Visual Tools. But there are PB'ers who EZGUI will fit their needs well.

                            Please do not take any of my comments here as a criticism of Pauls FireFly or any other Visual Designer tool (don't forget PwrDev).

                            They are excellent products, even if they use a different approach to programming than I use with EZGUI.

                            EZGUI is by no means perfect. As its developer I know its weaknesses more than anyone else. Yet, it does have strengths. It does have some advantages. I simply hope that my discussion of the product here will help some make the right choice (even if that means not to buy EZGUI).

                            This sale is the best offer yet for EZGUI and I don't want any who could benefit from it to lose the opportunity to get it so cheap.

                            Sadly, its the end of the year (and a rough one for many with the economy) and the time for sales , so both FireFly and EZGUI are being offered at the same time for sale which can cause confusion. I doubt either Paul or myself are having a sale simply to be a pain to the other. It is just the time of year for sales, businesses need to generate revenue (thats means me and Paul) and both products are on sale at the same time.

                            Please try to overlook any negatives in these discussions and simply use them as a way to learn more about each product. I have no doubt there will be many who will choose to buy FireFly and thats fine by me. They will definitely get their moneys worth.

                            If EZGUI appeals to you, please ask questions, get more info before buying (feel free to email me). Don't buy it simply because it is on sale.
                            Buy it because you feel it will fit your needs.

                            Happy customers are the best customers, IMO.
                            I get better word of mouth advertising from customers who love the product, than those who simply shelve it, because they just bought it because it was on sale and then don't use it.

                            Just ask my customers. I will bend over backwards (thats an expression, so don't expect gynastics) to help my customers get the most out of the product.
                            Chris Boss
                            Computer Workshop
                            Developer of "EZGUI"


                            • #15
                              This sale has been extended (read first post for details) and slightly changed.

                              I have had a good response so far to this sale, so I am continuing for another month.
                              Chris Boss
                              Computer Workshop
                              Developer of "EZGUI"


                              • #16
                                Who benefits most from EZGUI 4.0 Pro ?

                                This sale won't last forever so don't let it go by.

                                EZGUI will go back to its normal $249 price after the sale.

                                Personally, I feel EZGUI is worth the $249 price I sell it for.

                                The real question is:

                                Who benefits most from EZGUI 4.0 Pro ?

                                If you are simply looking for a GUI development tool which can build a basic GUI and let you code easily, then there are many choices worth considering and they all are quality tools.

                                Where EZGUI shines, is with those that want to push their GUI's to the limits.

                                EZGUI was originally designed, simply to make programming Windows apps easier (aka. EZ or Easy). Thats was with version 1.0.

                                In each the next generations of EZGUI, I found that the basics were not enough, so I concentrated on the feature set of the runtime engine. I started to add some custom controls, more graphics, ownerdraw support, etc.

                                By the fourth generation of EZGUI, the feature set has become very extensive. Its hard to actually number the amount of features, since many are simply commands in the runtime, many commands work with multiple controls (so actually this means more actual tasks are being done), many features are part of the event engine, many are part of the subclassing engine (ie. drag and drop) and many features are simply integral to the entire engine. Suffice it to say, EZGUI has one of the largest (if not the biggest) feature set of any third party tool for PowerBasic. Many of the features are low level, many are ligh level.

                                The point is, that EZGUI shines when the user pushes their apps to the limits. Any Designer can build apps with buttons, listboxes, listviews, treeviews, etc. But where EZGUI shines is when you want to customize those controls and go beyond the basics with them. Sure, one could use the API to customize such things, but EZGUI makes such advanced customizations easy to do.

                                Everything from Graphics, Printing to MultiMedia. EZGUI does all of this.

                                If you can visually design your apps with a simple Dialog Editor, then EZGUI likely is not for you.

                                If you rarely use the common controls, then EZGUI is likely not for you.

                                If you don't need graphics, printing, multimedia or such things then EZGUI likely is not for you.

                                Now, if you have a need to develop extremely complex Windows applications, which go far beyond the basics and to do it quickly and easily , then EZGUI may just be what you are looking for.

                                If you are trying to push your apps to the limit, need more and more features which go beyond the basics, need to develop apps that are more advanced than anything out there, then seriously consider EZGUI 4.0 Pro.

                                Just one example to demonstrate the difference:

                                No other Visual Designer comes with anything close to EZGUI's Canvas control.

                                The Canvas control is more than just a display image control.

                                The EZGUI Canvas control supports double buffers and DIB section buffers (16,24 or 32 bit). You can easily write image filters using the DIB engine.

                                But there is more.

                                The Canvas control has a complete graphic engines to support, drawing bitmaps, icons, imagelists, text, shapes, control elements.

                                But there is more.

                                The Canvas control graphics engine can also draw PolyBeziers or Polygons without using arrays. Yes, thats right. EZGUI uses a simple string based multipoint definition system, which allows you to define a shape using relative coordinates, rather than fixed coordinates. This means, you can define a shape once and then draw it over and over again in different places and sizes and never have to recalculate any points.

                                But there is more.

                                The Graphics engine can draw multiple types of gradients, such as left to right, right to left, top to bottom and even 3D gradients.

                                But there is more.

                                Now add this, EZGUI's new Sprite engine!
                                Yes you can show/hide/move non-rectangular Images on top of the Canvas (does not effect the actual Canvas background). Sprites can even be animated using multiple frames.

                                But there is more.

                                Sprites can even be AlphaBlending to each other and the background. They can also be anti-aliased.

                                But there is more.

                                Sprites are objects themselves and can be drawn on too!

                                But there is more.

                                The Canvas controls can generate a region based on its current image (background) on the fly, so you can change its actual shape.

                                Now of course you can get features like this with something like GDImage, but remember ...

                                All of this is part of a complete integrated Visual Designer/GUI Code Generator/GUI runtime package. You don't have to purchase a tool just for graphics, but you get it all in one package.

                                Also EZGUI's graphics are designed to be used on Windows 95 to Vista, so you are not limited by a particular operating system nor do you have to distribute an OS runtime for earlier OS's.

                                Now remember, EZGUI is not a game engine nor is it trying to be one.
                                EZGUI provides such features so you can build commercial quality, business based apps which are graphic oriented.

                                What other Visual Designer tool does this ?

                                If you need to go beyond the basics, push Windows to the limits while still being able to run your apps on legacy systems, want your app to fit on a floppy disk and to do all of this with just one package, then seriously consider EZGUI 4.0 Pro.

                                With this current sale, you can purchase EZGUI 4.0 Pro for less that some third party graphic tools alone and you get a complete development system, with graphics, multimedia and all sorts of ways to customize an app.
                                Last edited by Chris Boss; 9 Jan 2009, 10:19 AM.
                                Chris Boss
                                Computer Workshop
                                Developer of "EZGUI"


                                • #17
                                  I would like to note here that when it comes to Graphics in Windows applications that there are different levels of the use of graphics.

                                  (1) Basic simple drawing (using the basic GDI, etc.) (ie. draw boxes, circles, text)

                                  (2) Intermediate graphics. Meaning some high level graphic drawing, basic multimedia and basic animation. This is more than simple graphics, but usually software based (not hardware) and geared towards apps that are very graphic orientated, but not leading edge.

                                  EZGUI 4.0 Pro falls into this catagory.

                                  (3) High end, leading edge graphics based applications, which are primarily dealing with graphics, animation, multimedia. Such applications use every tool available in Windows (ie. DirectX, OpenGL, GDI+, hardware) to push graphics to the limit. Nothing but the best graphic tools are required to build such applications. Most developers in this cataqory don't write such tools themselves, but use third party tools developed by companies which are experts is this area. GDImage is most likely in this catagory than the previous one. But a rule of thumb though, when it comes to such tools is that "you get what you pay for". Most developers recognize you must be willing to pay the price for such tools, some even costing in the thousands (yes you read that right).
                                  Chris Boss
                                  Computer Workshop
                                  Developer of "EZGUI"


                                  • #18
                                    Is there a test version ?


                                    I am interested, is there a test version of easygui pro ?



                                    • #19
                                      There is no demo version of EZGUI 4.0 Pro.

                                      There are though some downloads which demonstrate EZGUI's features:

                                      Layered Window and Animation Demo:

                                      Sprites Demo:

                                      Help file about all the command set:

                                      Here are some other posts where I discuss its features in more detail:
                                      User to user discussions of third-party addons and user-recommended links to related web sites. Advertisements are permitted only in this forum, for products designed to work with and enhance PowerBASIC compilers.

                                      User to user discussions of third-party addons and user-recommended links to related web sites. Advertisements are permitted only in this forum, for products designed to work with and enhance PowerBASIC compilers.

                                      User to user discussions of third-party addons and user-recommended links to related web sites. Advertisements are permitted only in this forum, for products designed to work with and enhance PowerBASIC compilers.
                                      Chris Boss
                                      Computer Workshop
                                      Developer of "EZGUI"


                                      • #20

                                        I have just ordered EZGUI 4.0 Pro with grafics.
                                        The samples looks nice