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 File Requester

Opening an ASL requester requires the use of three functions:

APTR request = AllocAslRequest( ULONG type, struct TagItem *tagList );
BOOL success = AslRequest( APTR request, struct TagItem *tagList );
VOID           FreeAslRequest( APTR request );

The first function you should call is AllocAslRequest(). This allocates the main data structure you will use, either a FileRequester structure or a FontRequester structure. You specify the type of requester you want for AllocAslRequest() by setting the type argument. This can be one of two values defined in <libraries/asl.h>: either ASL_FileRequest, to ask for a FileRequester structure, or ASL_FontRequest, to ask for a FontRequester structure.

Here's a listing of the FileRequester structure.

struct FileRequester    {          /* (from <libraries/asl.h>)     */
        APTR    rf_Reserved1;
        BYTE    *rf_File;          /* Filename pointer             */
        BYTE    *rf_Dir;           /* Directory name pointer       */
        CPTR    rf_Reserved2;
        UBYTE   rf_Reserved3;
        UBYTE   rf_Reserved4;
        APTR    rf_Reserved5;
        WORD    rf_LeftEdge,rf_TopEdge; /* Preferred window pos   */
        WORD    rf_Width,rf_Height;     /* Preferred window size  */
        WORD    rf_Reserved6;
        LONG    rf_NumArgs;        /* A-la WB Args, for multiselects */
        struct WBArg *rf_ArgList;
        APTR    rf_UserData;       /* Applihandle (you may write!!)  */
        APTR    rf_Reserved7;
        APTR    rf_Reserved8;
        BYTE    *rf_Pat;           /* Pattern match pointer          */
        };                         /* note - more reserved fields follow */

Whichever requester type you use, you must allocate the requester structure with the AllocAslRequest() function call. Do not create the data structure yourself. The values in this structure are for read access only. Any changes to them must be performed only through asl.library function calls.

Once you have set up a requester structure with AllocAslRequest(), call AslRequest() to make the requester appear on screen. AslRequest() takes the requester data structure as an argument using it as a specification for the requester that it creates on screen.

The ASL File Requester

AslRequest() is always synchronous to the calling program. That is, control does not return to your program until the user makes a selection or cancels. AslRequest() returns TRUE, if the user selects a file (or a font). In that case the file (or font) name that the user selected is returned in the requester data structure. AslRequest() returns FALSE if the user cancels the requester or the requester failed for some reason.

When you have finished with a requester use the FreeAslRequest() function to deallocate the requester data structure.

Specifying Requester Options With TagItems

Both AllocAslRequest() and AslRequest() accept a TagItem array or tag list as an argument. The tag list is used to initialize or alter the values in the requester data structure.

A single TagItem consists of a tag name and an associated tag value. Tag items that apply to the asl.library are defined in <libraries/asl.h>. The basic tag items (used in the first example listed below) are:

Requester Tag Name	Used For
ASLFR_Window	Specifies the parent window of the requester
ASLFR_TitleText	String to place in the title bar of the requester window
ASLFR_InitialWidth	Requester window width
ASLFR_InitialHeight	Requester window height
ASLFR_InitialLeftEdge	Requester window y origin
ASLFR_InitialTopEdge	Requester window x origin
ASLFR_PositiveText	String to place in OK gadget of requester
ASLFR_NegativeText	String to place in Cancel gadget of requester
ASLFR_InitialFile	Default file name (for file requesters only)
ASLFR_InitialDrawer	Default directory name (for file requesters only)
ASLFR_InitialPattern	Initial pattern-matching string
ASLFR_DoSaveMode	Specifies that this file requester is a save requester (this replaces the FILF_SAVE flag in the ASL_FuncFlags tag used in V37).
ASLFR_DoMultiSelect	Enables multiple selection of files (this replaces the FILF_MULTISELECT flag in ASL_FuncFlags used in V37).
ASLFR_DoPatterns	Causes a pattern gadget to be included in the requester (this replaces the FILF_PATGAD flag in ASL_FuncFlags used in V37).
ASLFR_DrawersOnly	Causes the requester to only display drawers (this replaces the FIL1F_NOFILES flag in ASL_ExtFlags1 used in V37).
ASLFR_RejectIcons	Causes the requester not to display Workbench icons.
ASLFR_RejectPattern	Specifies an AmigaDOS pattern used to reject files.
ASLFR_AcceptPattern	Specifies an AmigaDOS pattern used to accept files.
ASLFR_FilterDrawers	Makes ASLFR_RejectPattern and ASLFR_AcceptPattern apply to drawer names.

Note that you are currently limited to about six characters for the replacement text if you use either the ASL_OKText or ASL_CancelText tags to change the text that appears in the OK and Cancel gadgets.

The contents of an ASL requester data structure are preserved across calls to AslRequest(). So, until the requester is freed, tag settings and user selections will remain in the data structure unless they are altered by tags in subsequent calls to AslRequest(). This is very useful because it allows the requester to remember and redisplay the user's previous selections. However, this also means that the programmer must assure that any addresses passed in ASL tags remain valid, or are refreshed on each call to AslRequest().

Generally, options that you wish to specify only once, such as the initial position and size, should be specified as tags when you allocate the requester. Options that you wish to control for each use of the requester should be passed as tags each time the requester is opened with AslRequest().

Simple ASL File Requester Example

Here's a short example showing how to create a file requester with asl.library. If AslRequest() returns TRUE then the rf_File and rf_Dir fields of the requester data structure contain the name and directory of the file the user selected. Note that the user can type in the a name for the file and directory, which makes it possible for a file requester to return a file and directory that do not (currently) exist.

// filereq.c
#include <exec/types.h>
#include <exec/libraries.h>
#include <libraries/asl.h>
 
#include <proto/dos.h>
#include <proto/exec.h>
#include <proto/asl.h>
 
#define MYLEFTEDGE 0
#define MYTOPEDGE  0
#define MYWIDTH    320
#define MYHEIGHT   400
 
struct AslIFace *IAsl = NULL;
 
struct TagItem frtags[] =
{
    ASL_Hail,       (uint32)"The Amiga file requester",
    ASL_Height,     MYHEIGHT,
    ASL_Width,      MYWIDTH,
    ASL_LeftEdge,   MYLEFTEDGE,
    ASL_TopEdge,    MYTOPEDGE,
    ASL_OKText,     (uint32)"O KAY",
    ASL_CancelText, (uint32)"not OK",
    ASL_File,       (uint32)"asl.library",
    ASL_Dir,        (uint32)"libs:",
    TAG_DONE
};
 
int main(int argc, char **argv)
{
    struct Library *AslBase = IExec->OpenLibrary("asl.library", 50);
    IAsl = (struct AslIFace*)IExec->GetInterface(AslBase, "main", 1, NULL);
    if (IAsl != NULL)
    {
        struct FileRequester *fr = IAsl->AllocAslRequest(ASL_FileRequest, frtags);
        if (fr != NULL)
        {
            if (IAsl->AslRequest(fr, NULL))
            {
                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->FreeAslRequest(fr);
        }
        else IDOS->Printf("User Cancelled\n");
    }
 
    DropInterface((struct Interface*)IAsl);
    CloseLibrary(AslBase);
    return 0;
}

File Pattern Matching and Multiple Selects

A file requester can filter out certain file and directory entries using the "wildcard" feature of AmigaDOS. To activate the wildcard feature for a file requester, you use the ASL_FuncFlags tag. Each bit in the ASL_FuncFlags tag item controls a special option of the requester depending on its type (file or font). See <libraries/asl.h> for a complete listing of the options that the ASL_FuncFlags tag controls.

File Requester Flag	Used For
FILF_PATGAD	Enables the file name pattern matching gadget
FILF_MULTISELECT	Enables multiple selection of files
FILF_NEWIDCMP	Use separate IDCMP for requester sharing a custom screen (see below)
FILF_SAVE	Makes the file requester a save requester (see below)

If the FILF_PATGAD bit of the ASL_FuncFlags tag is set, the file requester will appear with a "Pattern" gadget in addition to the usual file name and directory name gadgets. The user can type an AmigaDOS wildcard pattern into this gadget and the pattern will be used to limit the file names that appear in the requester. An application can also supply a default pattern using the ASL_Pattern tag item. A hidden unchangeable pattern can be created by supplying an ASL_Pattern without a FILF_PATGAD gadget. Such invisible patterns should not be used if there is any reason that the user may need to access a file which does not match the pattern.

Another feature of the ASL file requester is multiple selection. When multiple selection is enabled, the user can choose more than one file name in a single directory by selecting names in the requester's scrolling list gadget with the mouse. This option, like pattern matching, is set up with the ASL_FuncFlags tag.

If the FILF_MULTISELECT bit of the ASL_FuncFlags tag is set, the file requester will allow multiple selection. When the user selects several file names through the multiple selection feature, the FileRequester's rf_NumArgs field contains the number of files selected and the rf_ArgList field contains a pointer to an array of WBArg structures (defined in <workbench/startup.h>). There is a WBArg structure containing a file name for each file the user selected.

The following example illustrates a file requester with both a pattern matching gadget and multiple selection enabled.

/*
** filepat.c
*/
#include <exec/types.h>
#include <intuition/intuition.h>
#include <intuition/screens.h>
#include <graphics/displayinfo.h>
#include <libraries/asl.h>
#include <workbench/startup.h>
 
#include <proto/asl.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/dos.h>
 
struct AslIFace *IAsl = NULL;
struct IntuitionIFace *IIntuition = NULL;
 
struct Screen *screen = NULL;
struct Window *window = NULL;
 
int main(int argc, char **argv)
{
    struct FileRequester *fr;
    struct WBArg *frargs;
    int x;
 
    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)
    {
       if (screen = IIntuition->OpenScreenTags(NULL,
               SA_DisplayID, HIRESLACE_KEY,
               SA_Title, "ASL Test Screen",
               TAG_END))
       {
           if (window = IIntuition->OpenWindowTags(NULL,
                   WA_CustomScreen, screen,
                   WA_Title, "Demo Customscreen, File Pattern, Multi-select",
                   WA_Flags, WINDOWDEPTH | WINDOWDRAG,
                   TAG_END))
           {
               if (fr = (struct FileRequester *)
                   IAsl->AllocAslRequestTags(ASL_FileRequest,
                       ASL_Hail, "FilePat/MultiSelect Demo",
                       ASL_Dir,  "libs:",
                       ASL_File, "asl.library",
 
                       /* Initial pattern string for pattern matching */
                       ASL_Pattern, "~(rexx#?|math#?)",
 
                       /* Enable multiselection and pattern match gadget */
                       ASL_FuncFlags, FILF_MULTISELECT | FILF_PATGAD,
 
                       /* This requester comes up on the screen of this
                       ** window (and uses window's message port, if any).
                       */
                       ASL_Window, window,
                       TAG_END))
               {
                   /* Put up file requester */
                   if (IAsl->AslRequest(fr, 0L))
                   {
                       /* If the file requester's rf_NumArgs field
                       ** is not zero, the user multiselected. The
                       ** number of files is stored in rf_NumArgs.
                       */
                       if (fr->rf_NumArgs)
                       {
                           /* rf_ArgList is an array of WBArg structures
                           ** (see <workbench/startup.h>). Each entry in
                           ** this array corresponds to one of the files
                           ** the user selected (in alphabetical order).
                           */
                           frargs = fr->rf_ArgList;
 
                           /* The user multiselected, step through
                           ** the list of selected files.
                           */
                           for ( x=0;  x < fr->rf_NumArgs;  x++ )
                               IDOS->Printf("Argument %ld: PATH=%s FILE=%s\n",
                                   x, fr->rf_Dir, frargs[x].wa_Name);
                       }
                       else
                           /* The user didn't multiselect, use the
                           ** normal way to get the file name.
                           */
                           IDOS->Printf("PATH=%s FILE=%s\n", fr->rf_Dir, fr->rf_File);
                   }
                   /* Done with the FileRequester, better return it */
                   IAsl->FreeAslRequest(fr);
               }
               IIntuition->CloseWindow(window);
           }
           IIntuition->CloseScreen(screen);
        }
    }
 
    IExec->DropInterface((struct Interface*)IIntuition);
    IExec->CloseLibrary(IntuitionBase);
 
    IExec->DropInterface((struct Interface*)IAsl);
    IExec->CloseLibrary(AslBase);
 
    return 0;
}

The previous example demonstrates two alternate functions for creating and using ASL requesters:

APTR AllocAslRequestTags( uint32 type, Tag Tag1, ... );
BOOL AslRequestTags( APTR request, Tag Tag1, ... );

AllocAslRequestTags() can be used instead of AllocAslRequest() to allocate and set up the file requester. This is a function that will accept TagItems directly in its parameter list, rather than a pointer to an array of TagItems.

Similarly, AslRequestTags() will accept TagItems directly instead of requiring a pointer to an array of TagItems as AslRequest() does.

ASL Requesters and Custom Screens

An application that uses a custom screen normally wants its requesters to open on its screen. Using the ASL_Window tag, a program can associate a requester with a specific window so that the requester appears on the same screen as the window. The ASL_Window tag is followed by a pointer to a window structure. ASL_Window works with both file and font requesters. The example above shows how the ASL_Window tag is used with a file requester.

Normally, a requester associated with a window (using ASL_Window) shares that window's IDCMP port for its communication. An application may not want to share an IDCMP port with the requester. Using the ASL_FuncFlags tag, a program can ask for a requester that creates its own IDCMP port. There are two flags that accomplish this. The first, FILF_NEWIDCMP, is used on file requesters. The other, FONF_NEWIDCMP, is used on font requesters.

The Save Requester

The save requester is a special type of file requester used for save operations. It differs from the regular ASL file requester in several ways.

A save requester does not allow the user to select an existing file name by double-clicking on an entry in the scrolling list gadget. This helps prevent the user from accidentally overwriting the wrong file.

Save requesters can also create directories. If the user types a directory name into the save requester and the directory doesn't exist, the save requester will create that directory (after getting the user's permission via another requester).

To create a save requester, set the ASLFR_DoSaveMode tag to TRUE. Note that it does not make sense to have multiselection in a save requester, so the ASLFR_DoSaveMode tag overrides the ASLFR_DoMultiSelect tag.

The Directory Requester

Sometimes a program may only require a directory name from the user. There is another variation on asl.library's file requester that allows this. If the ASLFR_DrawersOnly tag is set to TRUE, the requester will appear without a string gadget for file names and will display only directory names in the scrolling list gadget. When AslRequest() (or AslRequestTags() ) returns successfully, the rf_Dir field of the FileRequester structure contains the name of the directory the user selected.

Another flag defined for ASL_ExtFlags1 is FIL1F_MATCHDIRS. If file pattern matching is on (see the FILF_PATGAD flag for ASL_FuncFlags), setting FIL1F_MATCHDIRS tells the file requester to pattern match directory names as well as file names. Of course, if both of these ASL_ExtFlags1 flags are set, the requester will only pattern match directory names.

Creating a Font Requester

The ASL library also contains a font requester. Using the font requester is very similar to using the file requester. First, allocate a requester structure with AllocAslRequest() or AllocAslRequestTags(). The type should be set to ASL_FontRequest in order to get a FontRequester structure:

struct FontRequester    {
    APTR    fo_Reserved1[2];
    struct TextAttr fo_Attr;    /* Returned TextAttr            */
    UBYTE   fo_FrontPen;        /* Returned pens, if selected   */
    UBYTE   fo_BackPen;
    UBYTE   fo_DrawMode;
    APTR    fo_UserData;
    /* missing from asl.h but present in this structure */
    SHORT   fo_LeftEdge, fo_TopEdge, fo_Width, fo_Height;
    };

Once the requester is set up, call AslRequest() or AslRequestTags() to make the requester appear on screen. These functions return TRUE if the user makes a selection. In that case, the font selected is returned as a TextAttr structure in the fo_Attr field of the FontRequester structure. (The TextAttr structure is defined in <graphics/text.h>. See the SDK for a complete listing.) If the user cancels the font requester FALSE is returned.

The ASL Font Requester

When the requester is no longer needed, call FreeAslRequest() to deallocate the requester data structure.

Specifying Font Requester Options With TagItems

As with a file requester, the font requester is specified with a TagItem list. There are several tags that are specific to the font requester:

Font Requester Tag Name	Used For
ASLFO_InitialName	Initial font name selection
ASLFO_InitialSize	Initial font size
ASLFO_InitialStyle	Initial setting of font Style gadget
ASLFO_Flags	Various font requester options
ASLFO_InitialFrontPen	Initial setting of Front Color gadget
ASLFO_InitialBackPen	Initial setting of Back Color gadget
ASLFO_ModeList	Alternate strings for Mode cycle gadget (see below)
ASLFO_MinHeight	Specifies the minimum height of fonts to be listed
ASLFO_MaxHeight	Specifies the maximum height of fonts to be listed
ASLFO_DoFrontPen	Causes the requester to display the Front Color selection gadget (this replaces the FONF_FRONTCOLOR flag in ASL_FuncFlags used in V37).
ASLFO_DoBackPen	Causes the requester to display the Back Color selection gadget (this replaces the FONF_BACKCOLOR flag in ASL_FuncFlags used in V37).
ASLFO_DoStyle	Causes the requester to display Style checkbox gadgets (this replaces the FONF_STYLES flag in ASL_FuncFlags used in V37).
ASLFO_DoDrawMode	Causes the requester to display the Mode cycle gadget.(this replaces the FONF_DRAWMODE flag in ASL_FuncFlags used in V37).
ASLFO_FixedWidthOnly	Causes the requester to list only fixed-width fonts (this replaces the FONF_FIXEDWIDTH flag in ASL_FuncFlags used in V37).
ASLFO_InitialDrawMode	Initial setting of the font Mode gadget.

Note that the last two tags only limit the range of font sizes that the font requester displays, the user is free to type in any value.

Font requesters have additional special options that are controlled through the ASL_FuncFlags tag. This tag works the same way as it does with file requesters but with different options available. Recall that the data for this tag is divided into bit fields, each of which controls a requester option. The flags used with the ASL_FuncFlags tag in a font requester are defined in <libraries/asl.h>:

Font Requester Flags	Used For
FONF_FRONTCOLOR	Enables font color selection gadgets
FONF_BACKCOLOR	Enables font background color selection gadget
FONF_STYLES	Enables font style selection gadget
FONF_FIXEDWIDTH	Limits display to fixed width fonts only
FONF_DRAWMODE	Enables font draw mode gadget

A simple font requester (one without any of the above FONF_ flags set) only lets the user choose a font and a Y size. Setting the flags above adds options to the font requester. FONF_FRONTCOLOR and FONF_BACKCOLOR add color selection gadgets to the requester, one for choosing a font's foreground color (labeled "Text") and the other for choosing the background color (labeled "Field"). The font requester records the user's setting in the FontRequester's fo_FrontPen and fo_BackPen fields.

FONF_STYLES sets up several gadgets to choose the style of the font (bold, italics, underline). The font requester saves these settings in the fo_Attr.ta_Style bit field according to the style flags defined in <graphics/text.h>. FONF_FIXEDWIDTH limits the font name display to fixed width (non-proportional) fonts (note that this does not prevent the user from typing in a proportional font name).

FONF_DRAWMODE adds a cycle gadget to the font requester so the user can choose the draw mode. The draw mode is saved in the requester's fo_DrawMode field. The number stored there corresponds to the draw mode's position in the gadget's cycle.

The draw mode cycle gadget initially is labeled "Mode" and has three elements in its cycle: "JAM1", "JAM2", and "Complement". These yield a result of 0, 1, and 2, respectively. It is possible to change the names and number of draw modes with the ASL_ModeList tag. This tag accepts a pointer to an array of strings. The first string replaces "Mode" as the label for the draw mode cycle gadget. The strings that follow replace the elements of the cycle gadget. The last entry in the array has to be NULL to tell the requester where the list of entries ends.

Example Font Requester

The following example illustrates how to use a font requester.

/*
** fontreq.c
*/
 
#include <exec/types.h>
#include <libraries/asl.h>
 
#include <proto/asl.h>
#include <proto/exec.h>
#include <proto/dos.h>
 
struct AslIFace *IAsl = NULL;
 
/* Our replacement strings for the "mode" cycle gadget.  The
** first string is the cycle gadget's label.  The other strings
** are the actual strings that will appear on the cycle gadget.
*/
CONST_STRPTR modelist[] =
{
    "Amiga Modes",
    "Mode 0",
    "Mode 1",
    "Mode 2",
    "Mode 3",
    "Mode 4",
    NULL
};
 
 
int main(int argc, char **argv)
{
    struct FontRequester *fr;
 
    struct Library *AslBase = IExec->OpenLibrary("asl.library", 50);
    IAsl = (struct AslIFace*)IExec->GetInterface(AslBase, "main", 1, NULL);
 
    if (IAsl != NULL)
    {
        if (fr = (struct FontRequester *)
            IAsl->AllocAslRequestTags(ASL_FontRequest,
                /* tell the requester to use my custom mode names */
                ASL_ModeList, modelist,
 
                /* Supply initial values for requester */
                ASL_FontName, "topaz.font",
                ASL_FontHeight, 11,
                ASL_FontStyles, FSF_BOLD | FSF_ITALIC,
                ASL_FrontPen,  0x00,
                ASL_BackPen,   0x01,
 
                /* Only display font sizes between 8 and 14, inclusive. */
                ASL_MinHeight, 8,
                ASL_MaxHeight, 14,
 
                /* Give all the gadgetry, but only display fixed width fonts */
                ASL_FuncFlags, FONF_FRONTCOLOR | FONF_BACKCOLOR |
                    FONF_DRAWMODE | FONF_STYLES | FONF_FIXEDWIDTH,
                TAG_END))
        {
            /* Pop up the requester */
            if (IAsl->AslRequest(fr, NULL))
            {
                /* The user selected something,  report their choice */
                IDOS->Printf("%s\n  YSize = %ld  Style = 0x%lx   Flags = 0x%lx\n"
                       "  FPen = 0x%lx   BPen = 0x%lx   DrawMode = 0x%lx\n",
                               fr->fo_Attr.ta_Name,
                               fr->fo_Attr.ta_YSize,
                               fr->fo_Attr.ta_Style,
                               fr->fo_Attr.ta_Flags,
                               fr->fo_FrontPen,
                               fr->fo_BackPen,
                               fr->fo_DrawMode);
            }
            else
                /* The user cancelled the requester, or some kind of error
                ** occurred preventing the requester from opening. */
                IDOS->Printf("Request Cancelled\n");
 
            IAsl->FreeAslRequest(fr);
        }
    }
 
    IExec->DropInterface((struct Interface*)IAsl);
    IExec->CloseLibrary(AslBase);
 
    return 0;
}

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_DONE;
 
    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()