AmigActive 4/AACD04.ISO/CDTools/ClassAct/ClassActFAQ.doc

Text File | 1997-07-09 | 20KB | 445 lines

        CLASSACT FAQ


THIS DOCUMENT

        This document was written to answer to frequently asked questions
        about the ClassAct GUI toolkit. It addresses both user and developer
        questions.  Sorry, some information is not quite up-to-date for
        ClassAct 2.0 yet.


MAINTAINER

        This FAQ is maintained by Osma Ahvenlampi <[e-mail]>


CONTENTS

        1.1 What is ClassAct?
        1.2 What's the availability?
        1.3 Why is it better than the other GUI toolkits?
        1.4 Where can I get ClassAct?
        1.5 Is there a mailing list?
        1.6 What uses ClassAct?

        2.1 What is in ClassAct?
        2.2 How about the developer support stuff?
        2.3 How does writing ClassAct applications differ from GadTools?
        2.4 From other toolkits?

        3.1 Can I change the way ClassAct looks?
        3.2 Is there a preferences editor?
        3.3 Can ClassAct use background patterns?

        4.1 What is this deferred refresh thing?
        4.2 How does it work?
        4.3 How do the gadgets interconnect?
        4.4 How does ClassAct support keyboard control?

THE FAQ

    1.1 What is ClassAct?

        ClassAct is a GUI toolkit for the Amiga, implemented as a set of
        easy to use shared BOOPSI class libraries.

        ClassAct provides object-oriented building blocks for your
        application in the form of Intuition BOOPSI classes available as
        either shared run-time libraries.  As they are standard classes,
        they may be used with any application environment supporting
        BOOPSI. However, ClassAct is a complete GUI system in its own right,
        supporting everything from simple buttons to an advanced listview
        class supporting multi-select, images, multi-column and more.
        In addition, a complete GUI fast window and layout system class that
        lets you create font-sensitive and resizable interfaces quickly
        and easily.

    1.2 What's the availability?

        Programs that use ClassAct can be made freely distributable,
        shareware, commercial, etc. as there is no fee for users!  When you
        purchase ClassAct, users of your software get to use all the
        functions/preferences of our classes.  This not only makes ClassAct
        a powerful and time-saving choice for software developers, but an
        affordable and convenient one as well.

        ClassAct is a commercial toolkit with a developer kit available for
        $69.95. This kit contains the latest ClassAct libraries, the C
        headers, and the programmer documentation, plus many example programs
        with source. The kit also includes a distribution license for the
        class libraries, which means that they can be distributed free of
        charge with the applications using them. For inclusion with software
        to be bundled and/or distributed with the AmigaOS, a special license
        is available.

        For freeware and shareware developers there is a special deal of the
        toolkit for only $39.95. The package is exactly the same and entitles
        the buyer to the same support, but the distribution license restricts
        the use of the toolkit to non-commercial programs. That means public
        domain, freeware, shareware and similar applications.

    1.3 Why is it better than other GUI toolkits?

        Since ClassAct all classes are BOOPSI, they automatically support all
        sorts of great features, such as window relativity (resizability),
        3.x gadgethelp, notification, and interconnections with other BOOPSI
        classes (which do not necessarily have to be ClassAct classes).
        ClassAct classes are totally standard BOOPSI objects, just like the
        colorwheel and gradient sliders that come with release 3.x of the
        Amiga's operating system.  ClassAct classes are built for speed,
        power and efficiency. Many systems are cumbersome or limited in
        ability, and user preference, often the result of trying to build
        on top of the limited GadTools system. Many people think BOOPSI and
        get scared off, this is only because until now, there have not been
        many BOOPSI objects to work with. Making a BOOPSI interface often
        requiers writing your own gadget classes since AmigaOS does not
        provide anything beyond the basic button, string and scroller.

        ClassAct provides all of the ground work, over 25 font adaptive
        feature rich classes, letting you concentrate on your application,
        and its GUI, not how to implement it or work around short comings
        of lesser systems.

        All ClassAct classes are compatible with 2.04 (V37) thru 3.1 (V40)
        releases of the Amiga operating system and take advantage of
        performance increases available in release 3.x.

    1.4 Where can I get ClassAct?

        ClassAct is availble NOW only from for just $39.95 USD for public
        domain and sharware authors, and $69.95 USD for commercial
        developers.  It can be ordered directly from Finale Development, Inc:

            Finale Development, Inc.
            P.O. Box 6905
            West Palm Beach, FL. 33405
            USA

            Phone: [phone]
            Fax: [phone]

             E-Mail: [e-mail]

        Demos and maintenance updates are available via FTP from:

        FTP: ftp.warped.com
             /pub/amiga/classact/ClassActDemo.lha
             /pub/amiga/classact/Classes-##-XXX-##.lha

             Where ##-XXX-## prepresents the date of the update release,
             for example: Classes-8-May-97.lha

        The ClassAct web site is at:
             WWW: http://www.warped.com/~timmer/classact/

    1.5 Is there a mailing list?

        Yes. To subscribe, send a message to;

        [e-mail]

        with the line,

        subscribe classact <your-email-address>

        in the BODY of the message. For example,

        subscribe classact [e-mail]

        This mailing list is the primary form of support for the toolkit.
        All of the developers read it and answer questions.

    1.6 What uses ClassAct?

        Several ClassAct applications are being developed. A few
        have already been, or are very near release;

        Excelsior BBS - The lastest version of E! BBS now usess ClassAct.

        SysInspector  - System Inspector, simular in purpose to Xoper
                        with a very attractive ClassAct GUI.

        EnPrint       - Epson Stylus printer driver/control software
                        Available from Endicor Technologies.

        IW225 Pro     - IW225 Professional TCP/IP Stack is now using
                        ClassAct for point & click GUI QuickPrefs
                        configuration as well as bundled with the
                        new DaFTP. Available from InterWorks.

        NewYork       - An NNTP News Reader, styled after Voodoo. In
                        beta stages of development, and like Voodoo,
                        this is being written by one one of the ClassAct
                        co-authors. Email [e-mail] for more info.

        NewIcons 3.0  - Recently release version of NewIcons, uses
                        ClassAct for NI3 prefs.

        AmiFTP        - AmiFTP, another popular GUI FTP client has been
                        re-implemented with ClassAct. More info at:

                        http://www.lysator.liu.se/~lilja/AmiFTP.html

        DaFTP'96      - The popular DaFTP has been re-implemented
                        using ClassAct.

        Voodoo        - A multithreaded mail reader with MIME support,
                        Rexx interface for OS 3.x, and  included
                        in the Amiga Technologies Surfer bundle.

                        http://www.niksula.cs.hut.fi/~oahvenla/voodoo/

        Thor 2.5      - The popular THOR news/email offline/tcp reader
                        is being ported to ClassAct. Available Soon!

                        Note, V2.5 beta/preview is available now for
                        registered users.

        Grapevine2    - A greatly enhanced version of the original GUI IRC
                        client is in the hands of a small group of
                        testers now - and a year later now, it still is. <g>

        CompactPlayer - A SCSI-2 audio CD player implemented as an early
                        demo of using ClassAct is available with source
                        from:

                        Aminet: /disk/cdrom/CompactPlayer.lha

        Asokoban3     - Amiga version xsokoban, a very impressive game.

        AmiLights     - A puzzel game, playable on the Workbench screen,
                        from Doug Dyer - author of the popular AmiCheck.

        A list with links to respective software is also on the ClassAct
        web page. And there is much more to come!


    2.1 What is in ClassAct?

        ClassAct is an expanding project. Currently over 30 different classes,
        and the number is expanding all the time. ClassAct also has some tools
        to aid in building user interfaces.  And here is a list of classes;

        Gadget Classes:
         * Button gadget class
            - powerful button class with many of options including built-in
              arrow glyphs, tab-cycle support, custom images and more.

         * CheckBox gadget class
            - for checkbox gadgets, very much like GadTools CHECKBOX_KIND.

         * Chooser gadget class
            - for pop-up and drop-down menus similar in purpose to GadTools
              CYCLE_KIND.

         * Clicktab gadget class
            - for file-folder tabs gadgets. May used in conjunction with
              the Page gadget to "flip" the virtual pages.

         * Fuel Gauge gadget class
            - for progress indication, several features including optional
              tick marks, and orientation settings.

         * Integer gadget class
            - an integer gadget with optional arrows.

         * Layout gadget class
            - for laying out gadgets and images in a font-sensitive and
              resizable hierarchical group fashion.

         * ListBrowser gadget class
            - a listview supporting multiple columns, images, multi-select,
              hierarchical lists, etc.

         * Page gadget class
            - a virtual page class for hiding groups of gadgets from view.

         * Palette gadget class
            - for color selection, like GadTools PALETTE_KIND.

         * RadioButton gadget class
            - for radio button gadgets, like GadTools MX_KIND.

         * Scroller gadget class
            - a proportional scrollbar with arrows, and slider mode.

         * SpeedBar gadget class
            - for button tool bars (horizontal or vertical orientations) with
              optional window title bar help messages.

         * String gadget class
            - a simple string gadget with bevel frame, compatible with
              strgclass.

        Image Classes:
         * Bevel image class
            - for drawing bevel grouping boxes
            - supports all kinds of standard bevels, including titled grouping.
              bevels, drop-box bevels, optional inner fill color and text, etc.

         * Draw List image class
            - for designing custom colorized and scaled vector/areafill images.

         * Glyph image class
            - for standard scalable system images
            - includes many images: arrows, get file, get font, etc.

         * Label image class
            - makes multi-line labels mixing text, colors, images, styles, etc.

         * Penmap image class
            - for pen-remapped images.

        Other Support Classes:
         * Window class
            - deferred layout & gadget refresh support.
            - automatic gadget keyboard control support with visual feedback.
            - iconification.
            - greatly simplified IDCMP processing.

         * ARexx class
            - simplifies creation and handling of ARexx ports.


    2.2 How about the developer support stuff?

        Here is some of what is included with ClassAct:

         - The complete set of ClassAct BOOPSI classes.
         - Autodocs in text and AmigaGuide format telling you how to use each
           class.
         - classact.lib (with source) which includes SAS/C and DICE autoopen
           support for ClassAct classes, plus useful support routines.
         - SBGen which allows you to quickly generate SpeedBar gadget source
           code and image data.
         - PMGen for creating penmap.image source data from pictures.
         - Examples programs in C for using each of the classes.
         - C includes that you will need for writing programs that use ClassAct.
         - Technical support from Phantom Development.

    2.3 How does writing ClassAct applications differ from GadTools?

        The first and foremost difference is that designing a GUI is much
        easier. Even with GUI builders such as GadToolsBox, making a GadTools
        GUI includes a lot of pixel-level tweaking to make it look right
        for font sensitivity, notably with various locales, and prop fonts.

        With ClassAct the GUI is described as a layout hierarchy, and the
        layout engine will take care of sizing and positioning gadgets. The
        developer need not, and should not, try to place objects in absolute
        positions. Resizability needs no extra work, because layout.gadget
        will scale the hierarchy to fit any size.

        Second, of course, is that the GadTools counterparts of ClassAct
        gadgets are much more restricted, if they in fact even exist at all.

        GadTools may be harder to use because many operations require that
        the gadgets be destroyed and recreated in some instances, eg resize,
        changing fonts/screens, etc. With ClassAct they don't even have to be
        detached from the window before modifying - they are BOOPSI objects.

    2.4 From other toolkits?

        Many available GUI toolkits are based on GadTools. While they make
        creating a GUI easier, they can not fix some deficiencies of
        GadTools. Because ClassAct is BOOPSI, these deficiencies often do
        not exist. In addition, ClassAct provides many gadgets and abilities
        absent from some other packages.

        In some ways, ClassAct resembles MUI. However, there are many big
        differences. ClassAct can be used at many levels. The simplest
        applications might only need a single gadget, such as the fuelgauge
        progress indicator. ClassAct allows putting single gadgets such as
        this into existing GadTools interfaces, because the gadgets are
        as useful independantly as they are when part of the whole. The
        gadgets send normal IDCMP messages back to the application, and do
        not require special front end event handlers. Exec and Intuition
        functions are enough to deal with ClassAct. On the other hand, the
        whole GUI can be quickly created using ClassAct gadgets, the
        ClassAct Window Class can even provide completely transparent
        keyboard shortcuts with no additional effort by the programmer.
        This is the prefered and recommended usage.


    3.1 Can I change the way ClassAct looks?

        ClassAct has a number of system-wide default settings. While we
        accept that some GUI features have to be user configurable, the
        common methods of providing this configurability have until now been
        sub-optimal. We are working on giving application-level
        configurability to ClassAct with a method that differs from the
        usual approaches to the problem. Suggestions welcome!

    3.2 Is there a preferences editor?

        Yes. An editor for setting global GUI preferences for things such as
        bevel styles, default window backfill patterns, fallback font label
        pen settings and built-in gadget imagery and so on is constantly
        being worked on. The current version is available in the demo and
        update archives and is provided free to all ClassAct users.

    3.3 Can ClassAct use background patterns?

        The layout system accepts both a simple RectFill pattern and a
        backfill hook for more complicated patterns (such as a background
        picture). It is very simple to use a generic backfill hook with
        ClassAct. Examples are provided on how to override the default hook.


    4.1 What is this deferred refresh thing?

        Normally, when a window requires refreshing, Intuition will
        automatically refresh the "damaged" regions in the window's borders
        and gadgets. However, with complex gadgets, this can take time, and
        that time is taken by input.device. Unfortunately input.device is
        responsible for other things too, such as moving the mouse pointer.
        A refresh of a window filled with complex BOOPSI gadgets can make the
        mouse pointer "freeze" for a second. Not only that, but since
        input.device runs at a high priority, the whole machine appears to
        stop for a fraction of a second while the refresh is taking place.

        This is even worse when the window is resized. Not only do the
        gadgets have to be redrawn, but also their size has to be
        recalculated. Resizing a window can stop input.device for even a
        couple of seconds at worst.

        ClassAct's window and layout classes work together to eliminate this
        problem. When using the deferred refresh feature of these classes,
        input.device can continue while the relayout and refresh are done by
        the application task.

    4.2 How does it work?

        The concept is quite simple. When a layout gadget receives a command
        to refresh itself and notices that it was dispatched by input.device,
        it will check whether it had been instructed to defer refreshes. If
        that is the case, it will, instead of refreshing itself, notify the
        window class that it should restart the refresh in the application
        context. Windowclass will then decide on the exact method of refresh
        based on the refresh type (smart or simple, possibly nocare) and send
        another refresh command to the layout gadget. Meanwhile, input.device
        can do something else.

    4.3 How do the gadgets interconnect?

        You can use the normal BOOPSI ICA_MAP and ICA_TARGET tags and the
        ic and model classes built in the OS. All of the ClassAct classes
        provide state information through the OM_NOTIFY method. In addition,
        the layout.gadget automatically connects objects to their labels,
        groups to each other, etc.

    4.4 How does ClassAct support keyboard control?

        The ClassAct window class, together with the layout class, will make
        keyboard control completely transparent to applications. As long as
        the gadget label contains a shortcut character (normally the
        character after a '_' character), the gadget will have a keyboard
        shortcut. Gadgets provide visual feedback through two custom gadget
        methods (documented in case you want to make your own custom gadget),
        ie. a button will "depress" when you press the shortcut key, and
        release when you release the key. The message you get afterwards is
        identical to a normal mouse button triggered gadget event. Window
        class can deal with several keys pressed down and other such special
        case events.