ASL Library

This page is currently being updated to AmigaOS 4.x. Some of the information contained here may not yet be applicable in part or totally.

ASL Library

This chapter describes the asl.library. The sole purpose of this library is to provide standard file and font requesters for application programs.

It is easier to understand the asl.library if you are familiar with some basic concepts of the Amiga operating system, especially TagItem arrays (described in Utility Library), Intuition screens and windows, graphics library font structures, and AmigaDOS pattern matching.

About Requesters

Requesters are temporary sub-windows used for confirming actions or selecting options. The most common type of requester is a file requester which is used to pick a file name for a load or save operation.

Under earlier versions of the Amiga operating system there was limited support for requesters. Intuition provides simple requesters which can be used to request responses such as OK or Cancel from the user. More elaborate Intuition requesters can be created by adding additional features such as string gadgets, however the result of this is that each application writer develops their own style of requester. With asl.library, requesters are much easier to create and take less memory.

Requesters are very flexible and can be used for many different purposes. The asl.library supports the three most common type of requesters:

• File requesters for choosing a file name in a load or save operation
• Font requesters for choosing a font in a text operation
• Screen Mode requesters for choosing a new screen with specific attributes

Common Tags Used by All Requester Types

These tags apply to all three types of ASL requesters: the file requester, the font requester and the screen mode requester. Each tag in the list below is prepended with ASLxx_. The actual tag names used by ASL will be prepended with ASLFR_, ASLFO_ or ASLSM_ depending on what type of requester is being used.

Tag Name	Used For
ASLxx_PubScreenName	Name of a public screen on which to open the requester.
ASLxx_Screen	Pointer to a screen on which to open the requester.
ASLxx_PrivateIDCMP	Specifies separate IDCMP for the requester window (this replaces the FILF_NEWIDCMP and FONF_NEWIDCMP flags in the ASL_FuncFlags tag used in V37).
ASLxx_IntuiMsgFunc	Function to call when an unknown message arrives at a shared IDCMP used by the requester window (this replaces the ASL_HookFunc tag and the FILF_DOMSGFUNC and FONF_DOMSGFUNC flags in the ASL_FuncFlags used in V37).
ASLxx_SleepWindow	Modal requester. Specifies that input should be blocked in the parent window.
ASLxx_UserData	A 32-bit value copied into the user data field of the requester structure.
ASLxx_TextAttr	Font to use for requester window gadgets and menus.
ASLxx_Locale	Locale (and language) to use for the requester window.
ASLxx_FilterFunc	Function to call for each item (file, font or mode) encountered. If the function returns TRUE, the item is displayed in the list view gadget, otherwise it is rejected and not displayed. (This replaces the ASL_HookFunc tag and the FILF_DOWILDFUNC and FONF_DOWILDFUNC flags in ASL_FuncFLags used in V37.)

Creating a Screen Mode Requester

The Screeen Mode requester provides application writers with a convenient way to ask the user for their screen display preferences. You create an ASL screen mode requester the same way you create an ASL file requester or font requester; only the tags and structures used are different.

There are three main functions to call:

AllocAslRequest()	Sets up the ScreenModeRequester structure you need.
AslRequest()	Displays the requester you have set up with AllocAslRequest().
FreeAslRequest()	Frees the ScreenModeRequester structure and other resources.

The first step is to set up a ScreenModeRequester structure with the AllocAslRequest() function. The ScreenModeRequester structure is defined in <libraries/asl.h> as follows:

 struct ScreenModeRequester {
     ULONG sm_DisplayID;            /* Display mode ID                  */
     ULONG sm_DisplayWidth;         /* Width of display in pixels       */
     ULONG sm_DisplayHeight;        /* Height of display in pixels      */
     UWORD sm_DisplayDepth;         /* Number of bit-planes of display  */
     UWORD sm_OverscanType;         /* Type of overscan of display      */
     BOOL  sm_AutoScroll;           /* Display should auto-scroll?      */
     ULONG sm_BitMapWidth;          /* Used to create your own BitMap   */
     ULONG sm_BitMapHeight;
     WORD  sm_LeftEdge;             /* Coordinates of requester on exit */
     WORD  sm_TopEdge;
     WORD  sm_Width;
     WORD  sm_Height;
     BOOL  sm_InfoOpened;           /* Info window opened on exit?      */
     WORD  sm_InfoLeftEdge;         /* Last coordinates of Info window  */
     WORD  sm_InfoTopEdge;
     WORD  sm_InfoWidth;
     WORD  sm_InfoHeight;
     APTR  sm_UserData;             /* You can store your own data here */
 };

The fields in this structure will be filled in with information obtained from the user. This information can then be used in your application to create the type of screen that the user prefers.

Note that for most programs, the user's preferred screen mode can be determined from the Amiga's Preferences subsystem. You do not have to use a screen mode requester. Consider carefully whether it is more appropriate to use an ASL requester or to obtain the information directly from the settings in Overscan and ScreenMode Preferences.

Listed below is a simple program that displays the new ASL screen mode requester including depth, width and height gadgets.

/*
** aslsm.c
*/
 
#include <exec/types.h>
#include <libraries/asl.h>
#include <utility/tagitem.h>
 
#define SMRTITLE "Simplest ScreenMode Requester"
 
struct AslIFace *IAsl;
 
int main(int argc, char **argv)
{
 
struct ScreenModeRequester *smr;
struct TagItem smrtags[5];
 
struct Library *AslBase = IExec->OpenLIbrary("asl.library", 50);
IAsl = (struct AslIFace*)IExec->GetInterface(AslBase, "main", 1, NULL);
 
if( IAsl != NULL)
    {
    smrtags[0].ti_Tag=ASLSM_TitleText;
    smrtags[0].ti_Data=(ULONG)SMRTITLE;
 
    smrtags[1].ti_Tag=ASLSM_DoWidth;
    smrtags[1].ti_Data=TRUE;
 
    smrtags[2].ti_Tag=ASLSM_DoHeight;
    smrtags[2].ti_Data=TRUE;
 
    smrtags[3].ti_Tag=ASLSM_DoDepth;
    smrtags[3].ti_Data=TRUE;
 
    smrtags[4].ti_Tag=TAG_END;
 
    if( smr = (struct ScreenModeRequester *)
          IAsl->AllocAslRequest(ASL_ScreenModeRequest, smrtags) )
        {
        if( IAsl->AslRequest(smr, 0L) )
            {
            IDOS->Printf("Display type: $%lx (see graphics/displayinfo.h)\n",
                    smr->sm_DisplayID);
            IDOS->Printf("Display width: %ld, height: %ld, depth: %ld\n",
                   smr->sm_DisplayWidth, smr->sm_DisplayHeight,
                   smr->sm_DisplayDepth);
            }              
        else
            IDOS->Printf("User cancelled or error...\n");  
 
        IAsl->FreeAslRequest(smr);
        }
    }
 
    IExec->DropInterface((struct Interface*)IAsl);
    IExec->CloseLibrary(AslBase);
 
    return 0;
}

As with other ASL requesters, the attributes of the screen mode requester are established using tag items when AllocAslRequest() is called. These attributes can later be changed by using different tag items in the AslRequest() call.

For instance, in the example above, tag items are used to specify that the screen mode requester should include gadgets for setting the display height (ASLSM_DoHeight), width (ASLSM_DoWidth) and depth (ASLSM_DoDepth).

Screen Mode Requester Tags

Here's a brief summary of the tag items that apply only to the ASL screen mode requester. For a complete listing of all ASL tag items, refer to the ASL include files and Autodocs.

Screen Mode Tag Name	Used For
ASLSM_Window	Parent window
ASLSM_Screen	Screen to open on if no window
ASLSM_PubScreenName	Name of public screen
ASLSM_PrivateIDCMP	Allocate private IDCMP?
ASLSM_IntuiMsgFunc	Function to handle IntuiMessages
ASLSM_SleepWindow	Block input in ASLSM_Window?
ASLSM_UserData	What to put in sm_UserData
ASLSM_TextAttr	Text font to use for gadget text
ASLSM_Locale	Locale ASL should use for text
ASLSM_TitleText	Title of requester
ASLSM_PositiveText	Positive gadget text
ASLSM_NegativeText	Negative gadget text
ASLSM_InitialLeftEdge	Initial requester left coordinate
ASLSM_InitialTopEdge	Initial requester top coordinate
ASLSM_InitialWidth	Initial requester width
ASLSM_InitialHeight	Initial requester height
ASLSM_InitialDisplayID	Initial display mode id
ASLSM_InitialDisplayWidth	Initial display width
ASLSM_InitialDisplayHeight	Initial display height
ASLSM_InitialDisplayDepth	Initial display depth
ASLSM_InitialOverscanType	Initial type of overscan
ASLSM_InitialAutoScroll	Initial autoscroll setting
ASLSM_InitialInfoOpened	Info window initially opened?
ASLSM_InitialInfoLeftEdge	Initial Info window left coordinate
ASLSM_InitialInfoTopEdge	Initial Info window top coordinate
ASLSM_DoWidth	Display Width gadget?
ASLSM_DoHeight	Display Height gadget?
ASLSM_DoDepth	Display Depth gadget?
ASLSM_DoOverscanType	Display Overscan Type gadget?
ASLSM_DoAutoScroll	Display AutoScroll gadget?
ASLSM_PropertyFlags	Must have these Property flags
ASLSM_PropertyMask	Only these should be looked at
ASLSM_MinWidth	Minimum display width to allow
ASLSM_MaxWidth	Maximum display width to allow
ASLSM_MinHeight	Minimum display height to allow
ASLSM_MaxHeight	Maximum display height to allow
ASLSM_MinDepth	Minimum display depth
ASLSM_MaxDepth	Maximum display depth
ASLSM_FilterFunc	Function to filter mode id's
ASLSM_CustomSMList	Exec list of struct DisplayMode

Calling Custom Functions from a Requester

The ASL_HookFunc tag passes an ASL requester a pointer to a custom function. The requester can use this function for two purposes. The first is to determine if the requester should display a particular file or font name. The other purpose is to process messages that the requester receives at its IDCMP port that are not meant for the requester. Hook functions are set up through flag values used with the ASL_FuncFlags tag:

Hook Function Flag	Used For
FILF_DOWILDFUNC	Call user hook function on each name in a file requester
FONF_DOWILDFUNC	Call user hook function on each name in a font requester
FILF_DOMSGFUNC	Call user hook function for IDCMP messages not used by a file requester
FONF_DOMSGFUNC	Call user hook function for IDCMP messages not used by a font requester

The FILF_DOWILDFUNC and FONF_DOWILDFUNC flags cause a requester to call the function you specify with the ASL_HookFunc tag for every file or font entry. The requester displays the file or font name only if your hook function tells it to. For a file requester, if your hook function returns a zero, the file requester will display the file name. For a font requester, if your hook function returns anything but zero, the font requester will display the font name and size.

The FILF_DOMSGFUNC and FONF_DOMSGFUNC flags cause a requester to call your hook function whenever it receives an IntuiMessage that it cannot use at the IDCMP port that it shares with your window. (See the section on "ASL Requesters and Custom Screens" earlier in this chapter for more information about sharing IDCMP ports.) If the requester receives any messages that are not meant for the requester it will call your hook function (specified with the ASL_HookFunc tag). Your hook function is responsible for returning a pointer to the IntuiMessage. The requester will take care of replying to the message.

Parameters Passed to Custom Hook Functions

A requester always passes three parameters to your custom hook function:

ULONG MyHookFunc(ULONG type, CPTR object, CPTR AslRequester)

If MyHookFunc() is called from a file requester doing _DOWILDFUNC, the three parameters are:

type

FILF_DOWILDFUNC

object

pointer to an AnchorPath structure (from <dos/dosasl.h>)

AslRequester

pointer to the FileRequester that called the hook function

The hook custom function should return a zero to display this file.

The AnchorPath structure is a dos.library structure used in pattern matching. Refer to the AmigaDOS Manual, 3rd Edition for more information.

If MyHookFunc() is called from a font requester doing _DOWILDFUNC, the three parameters are:

type

FONF_DOWILDFUNC

object

pointer to a TextAttr structure (from <graphics/text.h>)

AslRequester

pointer to the FontRequester that called the hook function

The hook custom function should return non-zero to display this particular font size.

If MyHookFunc() is called from a file or font requester doing _DOMSGFUNC, the three parameters are:

type

FILF_DOMSGFUNC (file requester) or FONF_DOMSGFUNC (font requester)

object

pointer to the IntuiMessage for the function to process

AslRequester

pointer to the FileRequester or FontRequester that called the hook function

The hook custom function should return a pointer to the IntuiMessage.

Notice that it is possible for a requester to use both _DOWILDFUNC and _DOMSGFUNC at the same time. Your hook function has to differentiate between the two cases by testing the type passed to it. It is not possible for a font and file requester to share a hook function for a _DOWILDFUNC, because FILF_DOWILDFUNC is defined to be the same value as FONF_DOWILDFUNC, so the hook function cannot tell if the object (from the prototype above) is a pointer to an AnchorPath structure or a pointer to a TextAttr structure. It is possible for font and file requesters to share one hook function for _DOMSGFUNC (even though FILF_DOMSGFUNC and FONF_DOMSGFUNC are equal) because, in this case, font and file requesters both call your hook function in the same manner.

Example ASL Requester With Custom Hook Function

The following example illustrates the use of a hook function for both _DOWILDFUNC and _DOMSGFUNC.

/*
** filehook.c
*/
#include <exec/types.h>
#include <intuition/intuition.h>
#include <dos/dosasl.h>
#include <libraries/asl.h>
 
#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/asl.h>
#include <proto/intuition.h>
 
#define DESTPATLENGTH 20
 
struct AslIFace *IAsl = NULL;
struct IntuitionIFace *IIntuition = NULL;
 
struct Window  *window = NULL;
 
/* this is the pattern matching string that the hook function uses */
CONST_STRPTR sourcepattern = "(#?.info)";
TEXT pat[DESTPATLENGTH];
 
uint32 HookFunc(int32 type, APTR obj, struct FileRequester *fr);
 
 
int main(int argc, char **argv)
{
    struct FileRequester *fr;
 
    struct Library *AslBase = IExec->OpenLibrary("asl.library", 50);
    IAsl = (struct AslIFace*)IExec->GetInterface(AslBase, "main", 1, NULL);
 
    struct Library *IntuitionBase = IExec->OpenLibrary("intuition.library", 50);
    IIntuition = (struct IntuitionIFace*)IExec->GetInterface(IntuitionBase, "main", 1, NULL);
 
    if (IAsl != NULL && IIntuition != NULL)
    {
            IDOS->ParsePattern(sourcepattern, pat, DESTPATLENGTH);
 
            /* open a window that gets ACTIVEWINDOW events */
            if (window = IIntuition->OpenWindowTags(NULL,
                    WA_Title, "ASL Hook Function Example",
                    WA_IDCMP, IDCMP_ACTIVEWINDOW,
                    WA_Flags, WFLG_DEPTHGADGET,
                    TAG_END))
            {
                if (fr = IAsl->AllocFileRequest())
                {
                    if (IAsl->AslRequestTags(fr,
                        ASL_Dir, "SYS:Utilities",
                        ASL_Window, window,
                        ASL_TopEdge, 0,
                        ASL_Height, 200,
                        ASL_Hail, "Pick an icon, select save",
                        ASL_HookFunc, HookFunc,
                        ASL_FuncFlags, FILF_DOWILDFUNC | FILF_DOMSGFUNC | FILF_SAVE,
                        ASL_OKText, "Save",
                        TAG_END))
                    {
                        IDOS_>Printf("PATH=%s FILE=%s\n", fr->rf_Dir, fr->rf_File);
                        IDOS->Printf("To combine the path and filename, copy the path\n");
                        IDOS->Printf("to a buffer, add the filename with Dos AddPart().\n");
                    }
                    IAsl->FreeFileRequest(fr);
                }
                IIntuition->CloseWindow(window);
            }
        }
    }
 
    IExec->DropInterface((struct Interface*)IIntuition);
    IExec->CloseLibrary(IntuitionBase);
 
    IExec->DropInterface((struct Interface*)IAsl);
    IExec->CloseLibrary(AslBase);
 
    return 0;
}
 
uint32 HookFunc(int32 type, APTR obj, struct FileRequester *fr)
{
    static BOOL returnvalue;
    switch(type)
    {
        case FILF_DOMSGFUNC:
        /* We got a message meant for the window */
            IDOS->Printf("You activated the window\n");
            return(obj);
            break;
        case FILF_DOWILDFUNC:
        /* We got an AnchorPath structure, should
        ** the requester display this file? */
 
            /* MatchPattern() is a dos.library function that
            ** compares a matching pattern (parsed by the
            ** ParsePattern() DOS function) to a string and
            ** returns true if they match. */
            returnvalue = IDOS->MatchPattern(pat,
                    ((struct AnchorPath *)obj)->ap_Info.fib_FileName);
 
            /* we have to negate MatchPattern()'s return value
            ** because the file requester expects a zero for
            ** a match not a TRUE value */
            return( ! returnvalue );
            break;
    }
}

Function Reference

The following are brief descriptions of the ASL library functions. See the SDK for details on each function call.

Function	Description
AllocAslRequest()	Allocates an ASL font or file requester from a TagItem array
AllocAslRequestTags()	Same as AllocAslRequest() but accepts tags directly
AslRequest()	Displays an ASL requester with options set up in a TagItem array
AslRequestTags()	Same as AslRequest() but accepts tags directly
FreeAslRequest()	Deallocates an ASL requester created with AllocAslRequest()