Search the FAQ Archives

3 - A - B - C - D - E - F - G - H - I - J - K - L - M
N - O - P - Q - R - S - T - U - V - W - X - Y - Z - Internet FAQ Archives

Portable GUI Development Kits FAQ, part 3/4

( Part1 - Part2 - Part3 - Part4 )
[ Usenet FAQs | Web FAQs | Documents | RFC Index | Schools ]
Archive-name: portable-GUI-software/part3
Posting-Frequency: monthly
Last-modified: 1997/03/02
Version: 3.1

See reader questions & answers on this topic! - Help others by sharing your knowledge
    Copyright 1996 Ross McKay. Last released $Date: 1997/03/02 09:04:40 $
    Copyright 1993-1995 Wade Guthrie. Permission is granted to copy and
    redistribute this document so long as it is unmodified (including the
    part that explains where to get the FAQ free-of-charge) and the
    copyright remains in-tact. I'd appreciate it if you told me about any
    redistribution, but that's not strictly necessary.

   The different PIGUI kits are classified by the language they support.
   These are the ones which support C and C++, with names O* to Z*. PIGUI
   kits for C and C++ from A* to N* can be found in Part 2 of the FAQ,
   and for other languages in Part 4 of the FAQ.
   _C/C++ from O to Z_
          Open Interface Elements (Neuron Data)
          Simple User Interface Toolkit
          TWIN / The Willows Toolkit
          Visual Age
          WM_MOTIF User Interface Library
          XVT Portability Toolkit
          Yet Another Class Library
  Open Interface Elements, Version 3.0
          Neuron Data
          156 University Avenue,
          Palo Alto, California 94301
          (800) 876-4900 (inquiries)
          (415) 321-4488 (voice)
          Open Interface is an emulated PIGUI with a C++ API (as of Open
          Interface Elements 3.0). The software also comes with a WYSIWYG
          GUI builder which includes a script language that can co-exist
          with C or C++. Their C++ approach no longer uses a wrappers
          They include tons of extra widgets (which they call "Power
          Widgets") like business graphics (bar, pie, and line charts),
          images (all standard formats), a hypertext widget, and
          context-sensitive hypertext help.
          Other software in Open Interface includes international
          character support, portable drag-and-drop, multi-font support,
          full printer support, memory management, file I/O support as
          well as MS-Windows DDE support (the latter is, of course,
          `Nexpertobject' is an expert systems tool intended for GUI
          `C/S Elements' is a client/server for tying UI components to
          one of many supported relational databases. This allows the UI
          to control the database and changes in the database to be
          propagated back into the UI.
          `Smart Elements' is for integrating knowledge-based systems
          with Neuron's GUI stuff. This allows changes to objects in the
          knowledge based system to be propagated to the UI and vice
          versa. In addition, these are integrated with a scripting
          language which causes changes in both the knowledge base and
          the UI.
          Open Interface is an emulated GUI, that attempts to superset
          the features from the various GUIs they support.
          Particularly if one looks at Neuron Data's optional products,
          one can see a leaning toward support of DBMS and expert
          These guys claim to have 35% of the market share for PIGUI
          tools including some heavyweights like IBM, Microsoft,
          Hewlett-Packard, and AT&T).
          One user says, "[They've] Implemented all kinds of ideas such
          as being able to add items to scrolling lists using the +=
          operator in C++ etc etc etc. Found some bugs, but support was
          brilliant, and new releases were always pushing the frontiers
          forward. All bug reports have met with speedy response. It is
          expensive, but worth it. Great for object-oriented
          Another user agrees, "The only one [PIGUI] I would recommend is
          Neuron Data's Open Interface."
          However, one user cautions, "I [only] recommend doing
          development on a UNIX box or a Mac with this tool. The person
          using our [MS] windows copy has had some problems with ND
          corrupting its own data files and/or crashing windows."
          Another complaint I seem to be seeing concerns slow and poor
          technical support.
  OpenUI, v4.0
          Open Software Associates
          20 Trafalgar Square, 5th Floor
          Nashua, NH 03063
          (800) 441-4330 (voice)
          (603) 886-4330 (voice)
          (603) 598-6877 (fax)
          This interface supports C, Pascal, (ish) COBOL, and Ada. Not
          only is the C type safe for C++, but they're willing to supply
          a native C++ API if there's enough demand. The software comes
          with a WYSIWYG GUI builder. They also have a `platform pack', a
          less-expensive, de-featured package which allows software
          developed with OpenUI to be ported to other platforms.
          Their code supports stand-alone as well as client (GUI) /
          server Logic) application development. A client/server
          application can be developed in stand-alone mode.
          When you purchase the product, you receive 90 days of fax and
          e-mail support. Purchased support adds-in phone access as well
          as product updates.
          In addition to GUI portability, OpenUI provides TCP/IP and
          Open Software Associates have rewritten their integrated
          development environment (IDE), added support for their OpenWeb
          product, and improved the cross-platform handling of bitmaps.
          There is an online `Knowledge Base' for registered users. I
          checked out the KB for their OpenWeb product, and it's pretty
          slim (e.g. no entries for Bug!) but the OpenUI KB might be
          Open Software Associates has been around since 1990.
          Says one user, "Support is brilliant, among the best I have
          ever seen in the computer industry. Comes with a [GUI] builder,
          allows generation of new GUI classes using a concept of
          soft-classes (not quite inheritance, but fairly powerful). Good
          for when multi- platform support is needed, but not as powerful
          as OI for a single GUI application. They will port to other
          hardware fairly quickly. We got the SUN port within a month."
          Problems include "no file, printing or memory management
          support", according to Richard Chimera ( -- from
          a report "Evaluation of Platform Independent Interface
          Builders", dated March 1993). [I have heard since that their
          printer support has improved - Ross]
  Qt 1.1
          Troll Tech AS
          Postboks 6133 Etterstad
          N-0602 Oslo
          (+47) 2264 6949
          Qt is an object-oriented multi-platform GUI toolkit written in
          C++. It enables the developer to quickly create GUI
          applications from components, for delivery on Windows 95 and
          NT, and most UNIX/X11 systems. OS/2 is apparently in the works
          Qt is inherently customisable, and its object-oriented nature
          makes this fairly simple by extending existing components.
          Components interact using what Troll Tech call `signals/slots',
          rather than relying on callbacks, so components are able to
          interact on a more generic level.
          Good online documentation is available, so the developer does
          not have to search for the last place he/she left `that
          Both commercial and free software licenses are available.
  StarView 2.1
          Star Division
          2180 Sand Hill Road, Suite 320
          Menlo Park, CA 94025
          (800) 888-8527 (inquiries)
          (415) 233-0142 (fax)
          _NB: see COMMENTS below!
          This is a full C++ class library that comes with their
          DesignEditor which creates resource files. Some of the classes
          include SplitBar (a splittable scrollbar like a spreadsheet
          uses), tool boxes, status bars, file dialogs, and MS-Windows
          bitmap support via file stream IO.
          Other features/portability capabilities include international
          language support (being a German company selling software in
          the states, this makes a lot of sense) but not multi-byte
          character sets, full printer support (including page preview),
          endian-aware classes, platform-independent file specification,
          and drag&drop support.
          This product also comes with several general-purpose C++
          classes including Strings and a very complete complement of
          container classes (e.g., Queues, Lists, and Tables). These
          classes are included in a Microsoft Windows DLL for reduced
          memory usage.
          StarDivision seems to be pulling this product from the market,
          to be used only for in-house work like their applications for
          Linux et al. One paid-up user can't even get email responses
          from them regarding this. More information as it comes to hand.
          These guys are using their own code (originally written in C++,
          I might add) to put together a multi-platform word processor.
          Their word processor guys keep their PIGUI guys informed of any
          One really neat thing is that they've ported Microsoft's help
          to other platforms. They have special (though non-portable)
          Microsoft Windows OLE and DDE classes.
          OS/2 & NT in beta.
          They are working on OLE 2.0 classes as well.
          Most of the reports that I've seen on StarView have been
          extremely favorable with emphasis on their intuitive API. Ian
          Upright (, for example, says "If
          you're doing [PIGUI] development, I think you'd be insane to
          not check out StarView as an option. [...] The entire design of
          the library is very intelligent and VERY well thought out.
          [...] It also has system dependent hooks available. Such as the
          ability to trap [MS] windows messages of a HWND." Other users
          second this, "Their features for creating graphics and using
          output devices is marvelous." and "The class library is
          excellent. It's complete. [...] It's intuitive." "They have
          done a good job porting non-native user interface elements to
          other platforms."
          User support is their biggest problem. Even though they have
          two support people and their primary support guy is really
          helpful, this is still a major issue. "They've got one good
          tech support guy, Andreas [they've added another]. You may not
          be able to call and get an immediate answer, as they're not
          always in." Says another user, "The real disappointment with
          StarView has been their customer support. We've known times
          where they didn't return our calls for weeks. They've
          consistently been late with releases and shipments, and have
          made promises on the phone that were not kept." Another says
          that support is "abysmal" in the U.S. but good out of Hamburg
          (by phone).
  Simple User Interface Toolkit, v2.3
          University of Virginia
          SUIT is a (free-of-charge with strings attached) C-language
          library. It comes with source, a 10 page tutorial, and a 160
          page reference manual. SUIT's prime directive is ease of
          learning (estimated time to productivity is around 2 hours --
          oh, and there is that thing about not interfering with the
          natural advancement of an indigenous life form, but we won't
          get into that here =^> ). The software has the unusual trait
          that its user-interface is editable even while a SUIT
          application program is running.
          SUIT is available with source for free for Universities and
          non-profit organizations (for-profit organizations can license
          SUIT for around $25,000). Anyone can download it via anonymous
          ftp from ( for evaluation
          For more information finger `'
  TWIN / The Willows Toolkit
          Willows Software
          12950 Saratoga Avenue, Suite A
          Saragoga, CA 95070-4670
          +1 415 777 1820 (phone)
          +1 415 777 1827 (fax)
          TWIN is a cross-platform development kit based on the new APIW
          standard for cross-platform development (q.v.). Using TWIN's
          XPDK, you can port software written to the Windows API, to
          several Unix platforms and the Macintosh.
          The kit includes a library, drivers and a binary interface to
          allow developers to bring Windows API-based applications and
          dynamic link libraries to alternative platforms. The product
          includes debug and release versions of the library to support
          work in both environments. Also included are shell tools to
          port sources, resource compilers to include menus, bitmaps and
          icons in an application and a module definition compiler for
          building shared libraries.
          TWIN is different to most other API emulation toolkits, which
          will only enable developers to port software to which they have
          source code. Binary emulation enables the use of existing or
          third-party DLL's, VBX's and OCX's on the target platform.
          Willows offers several levels of support: Basic, Standard and
          Premium subscriptions, and `Strategic Consulting'.
          Basic, at $250 per annum, covers a CD-ROM subscription and some
          (unspecified) support. I will fill in the details on this level
          Standard, at $1000 per annum, covers the CD-ROM subscription,
          30-day installation support via e-mail and WEB, E-mail and WEB
          access for incident reporting and information, and access to
          on-line bug and resolution database via WEB for tracking
          status, for one developer.
          Premium, at $5000 per annum, includes Standard and adds:
          unlimited installation support, telephone support for 10
          incidents per annum (additional incidents in blocks of 10 p.a.
          for $1500), for unlimited number of developers / contacts.
          TWIN is based on the new European standard for cross-platform
          development, called _Application Programming Interface for
          Windows_ (APIW). This standard was adopted by the European
          Computer Manufacturers Association (ECMA) on 15 December 1995,
          and is currently awaiting approval from the International
          Standards Organisation (ISO). APIW is based on the Microsoft
          Windows API.
          TWIN is available for download, for non-commercial purposes
          only, from their Web site. Non-commercial users can also
          purchase TWIN (source and binary) on CD-ROM for about $80. For
          commercial developers, TWIN is subscription-based software (see
          SUPPORT, above).
          Willows Software is backed by ex-Novell chief, Ray Noorda.
          Future plans include support for Windows 95 (including the new
          controls), MFC and OWL class libraries and quicktime
          multimedia. A future version will feature a dynamic user
          interface, allowing users to choose between different user
          styles including WIN3.1, WIN95, Motif and MAC/OS. Using shared
          libraries, developers will be able to create and dynamically
          add additional interface styles.
          Dr. Bruce E. Wampler
      - mailing list, use subject ADD and put
               your email address in the body
          V is a C++ framework for simplifying the development of GUI
          applications. V was developed as a platform independent
          framework, and currently supports Microsoft Windows 3.1, Win32,
          and X Windows (using Athena widgets).
          V encapsulates a fairly complete set of the standard GUI
          objects (windows, buttons, lists, fields etc) as well as
          portable printing.
          V comes complete with source code, and will remain free to the
          public under the terms of the GNU Library General Public
          License. The distribution package includes source code, a
          compiled library for Windows 3.1, a 150 page manual in LaTex
          and PostScript, and several example programs.
          V was developed as a freeware GUI C++ framework, by Dr. Bruce
          Wampler. It is currently being used to teach programming to
          students of the University of New Mexico, both at the Junior
          level and for large projects at the Senior level.
          From looking at the Quick Reference online, it seems to be a
          well-constructed example of an Object Oriented framework
          (better than some of the commercial packages I've seen). I
          guess that's because it has been used as a teaching tool. I
          would be interested in hearing from anyone who has used V for a
          complex application; I'm sure it would have been successful.
          An OS/2 version is being worked on. A Macintosh version is
          stated as being a "someday thing".
          Some tools are being developed to support V, including a dialog
          designer, a HTML-based portable help system, and an icon
          editor. Clipboard functionality should be added to V by the
          next release.
  Visual Age
          VisualAge is an Integrated Development Environment (IDE) for
          visually developing software using components. Whilst the
          purists may argue that it isn't a _true_ visual development
          tool, it's certainly more of one than the likes of Visual Basic
          and Delphi.
          VisualAge is available for either C++ or a Smalltalk. Both
          versions come with a comprehensive library of components for
          developing GUI and client / server applications across
          VisualAge for Smalltalk is available on Windows, OS/2 and AIX.
          Presumably, so is VisualAge for C++.
          I have to admit not knowing much about this product, and would
          appreciate hearing from anyone who has used or evaluated it.
  Wind/U v3.2
          Bristol Technology Inc.
          241 Ethan Allen Highway Ridgefield, CT 06877
          (203) 438-6969 (voice)
          (203) 438-5013 (fax)
          Wind/U is an implementation of the Microsoft Windows API under
          Unix/Motif. Wind/U supports Win16 and Win32 and the Microsoft
          Foundation Classes 3.0 and 4.x (MFC, the API under Visual C++).
          It contains custom widgets to allow applications to utilize
          multiple document interface (MDI), combo boxes, dynamically
          linked libraries (DLLs), dynamic data exchange (DDE), WinSock,
          and PostScript and PCL4 and PCL5 (Hewlett Packard's Printer
          Control Language) printing. You can use your MS Windows Help
          file source on Unix with Bristol's HyperHelp.
          In addition, they support the Windows GDI graphics drawing
          interface, including the coordinate system choices. Finally,
          they support Common dialog DLLs as well as DDEML (Dynamic Data
          Exchange Management Library) DLLs. OLE was recently added.
          Recently, Wind/U added support for ActiveX and multi-threading
          under UNIX.
          Their toolkit includes several programmer tools including
          Wind/U Spy (an application that runs under Motif but looks like
          the MS-Windows Spy program), online documentation, a makefile
          generation program (to help compile your MS-Windows program
          under Unix), and other tools to help prepare your PC source for
          Bristol has entered into a source code license agreement with
          Microsoft. This agreement allows Bristol to incorporate
          MS-Windows code into their product.
          Bristol was founded in 1990 and has maintained a profit every
          quarter since 1992.
          One user says, "[Wind/U] is a fairly complete implementation of
          the Windows API for unix. There are some bugs, and some
          unimplemented features, but it seems to be getting better over
          time. Bristol's support for their product is truly excellent:
          they are very responsive and have been able to provide rapid
          turnaround for our problems."
          Others say "... remarkably unresponsive, ...their Win32 is
          *much* less complete than they [tell you]"
  WM_MOTIF User Interface Library, v4.1
          Software UNO, Ltd.
        15 Bodwell Terrace
        1259 Fernandez Juncos Ave.
        Millburn, NJ 07041
        San Juan, PR 00907
          (800) 840-UNIX (840-8649) (voice)
          (809) 723-5000
          (809) 722-6242 (fax)
               73710,3031; GO MAGMA
          WM_MOTIF is a portable implementation of the MS Windows API for
          Unix Motif and character-based environments. It is a C library,
          but also supports popular C++ frameworks like Microsoft's MFC
          or Borland's OWL. A resource compiler is included to port
          MS-Windows resources to the Unix platforms. WM_MOTIF supports
          bitmaps, icons, and cursors; UIL is not required.
          Source code is available.
          Demo executables are available via anonymous FTP at
 Software UNO also offers an
          evaluation library to allow developers to compile their own
          code with the library.
  WNDX 95
          Suite 418, 1167 Kensington Crescent N.W.
          Calgary, Alberta Canada T2N 1X7
          (403) 283-5590 (voice)
          (403) 283-6250 (fax)
          (403) 283-6395 (bbs)
          This is a C library which comes bundled with a resource builder
          (OPUS) capable of creating portable resource files.
          WNDX provides system-independent graphic drawing routines,
          window manipulation primitives, and user interaction management
          routines as well as dialogs, menus, editable and static text
          items, scrollbars, checkboxes, radio buttons, list items,
          selection items, icons, color selection items, icon and bitmap
          Programs generated with WNDX can be configured to use the
          native environment of the platform, or to be identical in
          appearance and behavior across all platforms. This is
          accomplished by the use of different `style guides' (source
          included) which define the look and feel of the particular
          `style'. For example, a simple menu option can change the look
          and feel of the OPUS application running in Windows from the
          Windows style guide to the Motif style guide.
          According to one article, they've altered concepts that most
          GUI developers consider conventional. All widgets have all the
          attributes defined for them (it's just that some of the
          attributes are meaningless and, therefore, ignored). WNDX
          describes it differently: The basis of the WNDX paradigm is the
          Window `object'. Each object has an attribute list. Other
          `objects' are derived from the basic window object and each
          kind of object adds different customized attributes to the
          attribute list.
          There are some problems, like colors are not fully editable and
          there's no way to put a picture on a button (without fudging).
          Other complaints include features (like icons) that require
          special non-portable effort to use in a native look-and-feel.
          In addition to the platforms supported, a source code license
          is available for programmers who need to port applications to
          other UNIX/Motif platforms. Contact WNDX for pricing.
  wxWindows, v1.65
          Dr Julian Smart
          Artificial Intelligence Applications Institute
          University of Edinburgh
          80 South Bridge
          EH1 1HN
          0131 650 2746 (voice)
          This is a (free-of-charge) C++ library with source (there's
          also a version for the Python language). For a GUI builder, you
          can use wxBuilder (which is available under MS-Windows or
          Motif), another program they have to translate the output of
          DevGuide (Sun's XView GUI builder) into wxWindows format, or
          yet another one to allow one to use Liant's class browser with
          the library.
          A dialog editor is available under Windows, which is simpler to
          use and more robust than wxBuilder.
          This package includes hypertext help (including a new
          HTML-based help system), printer support (this is better than
          some packages you have to pay for), and some nifty graphics
          capabilities including splines, polylines, and rounded
          rectangles. It includes the standard menu bars, toolbars, pens,
          brushes, etc. In addition to all of that, it includes IPC
          features that includes DDE support under MS-Windows _AND_ Unix.
          A CURSES version is in alpha.
          In addition, wxWindows includes timers, filesystem portability
          features, as well as PROLOGIO which allows the user to create
          (apparently, with some limitations) object-oriented, Prolog-
          compatible data files, document/view classes, a charting
          library, an HTML canvas, and ODBC support under Windows.
          wxWindows now supports Windows 3.1, WIN32, Windows 95 (not all
          controls and features), Windows NT, XView, and Motif. A
          contributed Xt port provides a large subset of the features
          available in the 'official' wxWindows distribution. A Mac port
          is also now available, but seems to be trailing the main gang
          in features. A partial OS/2 port is available as a start for
          potential OS/2 contributors.
          To get this software, anonymous ftp it from;
          it's under /pub/packages/wxwin. Checkout the manual online
          (address above).
          This is free software, so one should expect that it has a
          couple of warts relative to the packages for which one would
          pay. It (according to the author) doesn't stick too closely to
          the style guides of the individual platforms, but "most people
          won't know the difference [... the software has] a long way to
          go before I've used all the features [of the various GUIs]".
          Still, the price is right, and to my mind it at least rivals
          (and in some cases, bests) the commercial offerings.
          + A wxWindows CD-ROM in the summer of 1996
          + further Win95 support
          + socket programming support
          + an OLE-2 class library
  XVT Portability Toolkit
   _XVT Development Solution for C++ (DSC++) 4.5_
   _XVT Development Solution for C (DSC) 4.5_
          XVT Software Incorporated
          4900 Pearl East Circle
          Box 18750
          Boulder, CO 80308
          (800) 678-7988 (inquiries)
          (303) 443-4223 (voice)
          (303) 443-0969 (fax)
          XVT comes as either a C-language or C++ (called Power++)
          library. The C solution has bundled with it an interactive
          design tool and code generator. XVT provides printing support,
          drag-and-drop, portable help, portable bitmap support (palette
          control provides up to 24 bits of color), powerful portable
          typeface handling capability, and all the standard widgets
          (including toolbar, status bar, and tables). Version 4.5 adds
          tables, tree, dockable windows, and data-aware objects.
          The C++ solution includes a user interface layout tool
          (XVT-Architect) which includes a browser, a graphical layout
          tool and an object attributes manager.
          In addition, Power++ comes with the Rogue Wave product
          Tools.h++ (Tools.h++ provides 135 extra general-purpose
          Source Code
          XVT Spreadsheet
          XVT Graphical Extensions
          Free (with updates) for one year. After that, call for pricing.
          XVT is the original PIGUI software. They seem to provide pretty
          solid support for all the platforms (and, there's a lot) that
          they support. In addition, the current incarnation of their C++
          toolset is generally agreed to be substantially better than
          their original entry.
          XVT is receiving major applause for changing their PIGUI
          approach to be more consistent with the rest of the
          marketplace. They are getting away from a least-common
          denominator approach (check out their portable help for an
          example of strides in this area) and they are providing more
          complete packages with fewer optional extras (e.g., XVT now
          bundles their layout tool with their products).
          XVT was founded in 1987.
          The user's have said that the manuals are good and extremely
          well organized and that the Designer's test mode actually tests
          the logic (a really helpful feature). Their tech support is
          also reportedly pretty good ("wonderous", says one user).
          In the arena of software development, one user says " the
          end of 2 weeks we had a fully-functional [medium-sized]
          application on Mac and MOTIF", he goes on to say that the the
          user-interface was redesigned half way through.
          Power++ is said to be a fantastic improvement over their old
          C++ product (Design++).
          One user has a list server running, on, To
          subscribe, just send some mail to
  Yet Another Class Library, v1.5
          M. A. Sridhar
          Department of Computer Science
          University of South Carolina
          Columbia, SC 29208
          (803) 777-2427 (voice)
          (803) 777-3767 (fax)
          YACL is a freely available C++ class library that includes:
          + a suite of container and data storage classes for
            general-purpose programming
          + high-level GUI classes based on Model-View-Controller
          The GUI class protocols are designed in a platform independent
          manner, and are implemented under Motif 1.2 as well as under
          Microsoft Windows, Windows NT and OS/2. The YACL distribution
          includes numerous demo programs.
          YACL supports a multitude of compilers, and its distribution
          includes makefiles for all supported platforms and compilers.
          YACL is available via anonymous ftp from
          in /pub/yacl
  zApp, V3.0
          Rogue Wave Software
          260 SW Madison
          P.O. Box 2328
          Corvallis OR 97339
          (800) 487-3217 or (541) 754-3010
          A set of four software packages: zApp Factory, a WYSIWYG visual
          screen designer/ code generator; the zApp Application
          Framework, a set of over 200 classes for everything from
          geometry management to frames and panes; the zApp Interface
          Pack a set of high level custom controls; and zHelp, which
          provides portable context sensitive help to zApp Applications.
          The zApp Developer's Suite ships with the following
          documentation: Programmer's Guide, Programmer's Reference
          manual, a platform guide, zApp Factory manual and zApp
          Interface Pack manual.
          Version 3.0 adds progress bars, tabbed dialogs, tree,
          multi-selection lists, and better zHelp. zApp now also requires
          RogueWave's Tools.h++ class toolkit.
          Rogue Wave Software offers a full range of consulting and
          training to help your development group attain productivity.
          Technical support is provided through the phone, fax, email,
          compuserve and Rogue Wave's BBS. Purchase of a technical
          support contract provides priority support for one year as well
          as all upgrades (even major upgrades) at no additional charge.
          Prices for support for each zApp Developer's Suite are as
        Windows 95/NT, OS/2
        Full Platform Solution
          Future versions will offer integration with Rogue Wave
          libraries such as DBTools.h++ and Net.h++
          zApp for the Macintosh is _still_ scheduled ...
          Inmark, the originators of zApp, recently merged with
          RogueWave. I see this as only good news for zApp users, as
          RogueWave has quite a good reputation for quality
          cross-platform component software. The prices seem to have gone
          up with this, but then support more than likely has also.
          zApp receives many plaudits. Many users really like their class
          structure. One user says "zApp contains without a doubt the
          absolute best C++ code I have ever seen. It is an amazingly
          simple, intuitive interpretation of GUI and OOP interfaces".
          Another user says, "zApp is an EXCELLENT platform-independent
          API. If you truly must write your code `once' for multiple
          platforms, zApp is the C++ solution to get." Also revered is
          the zApp Factory tool.
          A big complaint seems to be that zApp is quite apparently
          MS-Windows-oriented. Many of their classes and idioms don't
          translate well (or at all) to other platforms. For example, one
          user says "my disappointment [with zApp] stems from my Mac
          expectations." Another user agrees, "The [MS] Windows version
          works rather better than the OS/2 version".
          A, possibly anachronistic, comment I've heard is "it has A LOT
          of memory leaks". On the other hand, [Inmark] has been
          listening to the complaints of it's customers, "We have been
          very diligent in tracking memory leaks and memory issues with
          zApp. The latest versions of zApp have been verified with [an
          in-house product, SmartHeap, BoundsChecker, and Purify]."
  Zinc, V4.2
          ZINC Software Incorporated
          405 South 100 East 2nd Floor
          Pleasant Grove, UT 84062
          (800) 638 8665 (inquiries)
          (801) 785-8900 (voice)
          (801) 785-8996 (fax)
          (801) 785-8997 (bbs)
          This is a full C++ class library that comes with the Zinc
          Designer (a WYSIWYG GUI builder). Their classes include a
          rather nice error system, geometry management, print support,
          VROOM support (for Borland heads), index tabs, status bars,
          sliders, spinners, some graphic capabilities, and a portable,
          if rudimentary, help system. Also included is the source for
          the library (and for the Designer).
          In addition to the usual GUI stuff, Zinc also provides
          international character support (they have a Unicode version
          for extra bux) and some container classes.
          The software comes with 4 manuals. These include 2 reference
          manuals, a getting started manual, and a document covering
          their designer.
          A set of database classes is now available, providing a
          database independance layer for C++ utilising several major
          data access methods, including ODBC.
          A Unicode version (key) is available for bux, allowing you to
          write truly internationalised code which includes Asian
          Zinc also provides a video training series (this gives lots of
          Zinc internals detail, but not a lot of relief for the novice
          programmer) for $499.
          Zinc's direction seems to be the international market along
          with support for the
          marketeers-do-the-GUI-while-programmers-do-the-code crowd. That
          said, they promise that they'll not forget about the
          applications and scientific programmers as they grow.
          To use their product to its fullest, you have to use their GUI
          builder (the only way you can get icons on all platforms, for
          example, is through the Designer).
          Zinc has made big changes to their Designer (their GUI builder)
          targeted, it seems, to provide a comfortable GUI design
          environment for non-programmers. The updates include easing the
          addition of user-defined widgets to the designer, parallelizing
          the main-design-screen/image-editor/help-editor, and replacing
          flag names with more user-friendly english descriptions.
          They have completely rewritten their manuals (and the crowd
          goes wild...) to reduce the learning curve associated with this
          Zinc was founded in 1990.
          The utilization of the native help system and improved graphics
          Users praise the look and feel under DOS. Native look-and-feel
          on target platforms also seems to be well met, in most cases.
          Many complain about the lack of intuitive feel of the API.
          Personally, I think that the API is pretty good but the
          documentation does a really poor job of explaining it. Zinc is
          based on message passing, similar in nature to how MS-Windows,
          OS/2 and Macintosh do it, but generalised to be portable across
          multiple platforms. Those of you who are more used to using
          callbacks may need to adjust.
          Some users say that the class hierarchy is not very Object
          Oriented. Others disagree, saying that subclassing is
          reasonably well supported, even to a limited extent within the
          Designer (GUI builder).
          There are some serious bugs associated with the table /
          spreadsheet object, UIW_TABLE. It seems they got it out the
          door too quickly. For lists with no in-place editing, you can
          get away with using a vertical list and owner-drawn elements
          but when you need a spreadsheet object, you're stuck with
          Zinc provides free email support for all customers, as well as
          limited phone and fax support. Zinc also offers a Customer
          Assurance Plan (CAP) which includes free phone, fax, email, BBS
          and Compuserve support, free upgrades and maintenance releases,
          and Beta test releases.
          Zinc's email support is quite responsive, especially for simple
          How-To questions. Several users have commented that Zinc is
          slow to fix bugs, but they are also open to negotiation for
          contract work.
          Once you get used to the paradigm, it _is_ pretty
          straight-forward to program. Their improved documentation is a
          big help and shows off some of Zinc's more powerful features.
          In addition, the software is becoming more robust with each
    Ross McKay
    $RCSfile: pigui3.txt,v $; $Revision: 3.1 $; $Date: 1997/03/02
    08:37:38 $

User Contributions:

Comment about this article, ask questions, or add new information about this topic:

Part1 - Part2 - Part3 - Part4

[ Usenet FAQs | Web FAQs | Documents | RFC Index ]

Send corrections/additions to the FAQ Maintainer:

Last Update March 27 2014 @ 02:12 PM