@DATABASE "amigaguide.guide"
@AUTHOR AmiS <amis@cch.pmc.ru> © 1998-99
@INDEX  ".Index.guide/MAIN"
@WORDWRAP
@$VER: amigaguide.library 40.4 autodocs 1.2
@HELP help

@NODE Help "Copyright 1998-99 AmiS"
 @{fg shine}amigaguide.library 40.4@{fg text}  Version 1.2
 This is a NewStyle Autodocs for Amiga Developer Community.

 Designed 1999 by @{fg shine}AmiS@{fg text}
 Send your bug report to @{fg fill}amis@cch.pmc.ru@{fg text}

@ENDNODE

@NODE Main "amigaguide.library"
@PREV Main
@{jcenter}@{b} A @{ub}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}A@{ub}@{lindent 4}
@{lindent 35}@{" AddAmigaGuideHostA()     " LINK "AddAmigaGuideHostA"}  - Add a dynamic node host.  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" AmigaGuideSignal()       " LINK "AmigaGuideSignal"}  - Obtain aysnc AmigaGuide signal.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainC "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{b} C @{ub}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}C@{ub}@{lindent 4}
@{lindent 35}@{" CloseAmigaGuide()        " LINK "CloseAmigaGuide"}  - Close a AmigaGuide client.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainG "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{b} G @{ub}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}G@{ub}@{lindent 4}
@{lindent 35}@{" GetAmigaGuideAttr()      " LINK "GetAmigaGuideAttr"}  - Get an AmigaGuide attribute.  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" GetAmigaGuideMsg()       " LINK "GetAmigaGuideMsg"}  - Receive async AmigaGuide message.  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" GetAmigaGuideString()    " LINK "GetAmigaGuideString"}  - Get an AmigaGuide string.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainL "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{b} L @{ub}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}L@{ub}@{lindent 4}
@{lindent 35}@{" LockAmigaGuideBase()     " LINK "LockAmigaGuideBase"}  - Lock an AmigaGuide client.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainO "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{b} O @{ub}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}O@{ub}@{lindent 4}
@{lindent 35}@{" OpenAmigaGuideA()        " LINK "OpenAmigaGuideA"}  - Open a synchronous AmigaGuide database@{lindent 4}
@{lindent 35}@{" OpenAmigaGuideAsyncA()   " LINK "OpenAmigaGuideAsyncA"}  - Open an AmigaGuide database async  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainR "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{b} R @{ub}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}R@{ub}@{lindent 4}
@{lindent 35}@{" RemoveAmigaGuideHostA()  " LINK "RemoveAmigaGuideHostA"}  - Remove a dynamic node host.  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" ReplyAmigaGuideMsg()     " LINK "ReplyAmigaGuideMsg"}  - Reply to an AmigaGuide message.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainS "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{b} S @{ub}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}S@{ub}@{lindent 4}
@{lindent 35}@{" SendAmigaGuideCmdA()     " LINK "SendAmigaGuideCmdA"}  - Send a command string to AmigaGuide  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" SendAmigaGuideContextA() " LINK "SendAmigaGuideContextA"}  - Align an AmigaGuide system on the context ID.  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" SetAmigaGuideAttrsA()    " LINK "SetAmigaGuideAttrsA"}  - Set an AmigaGuide attribute.  @{FG SHINE}(V34)@{FG TEXT}@{lindent 4}
@{lindent 35}@{" SetAmigaGuideContextA()  " LINK "SetAmigaGuideContextA"}  - Set the context ID for an AmigaGuide system.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainU "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{b} U @{ub}@{" OTHER " LINK MainOTHER 0}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}U@{ub}@{lindent 4}
@{lindent 35}@{" UnlockAmigaGuideBase()   " LINK "UnlockAmigaGuideBase"}  - Unlock an AmigaGuide client.  @{FG SHINE}(V34)@{FG TEXT}
@ENDNODE

@NODE MainOTHER "amigaguide.library"
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{b} OTHER @{ub}@{" CONTROL " LINK MainCONTROL 0}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}OTHER@{ub}@{lindent 4}
@{" --background--           " LINK "--background--"}
@{" --rexxhost--             " LINK "--rexxhost--"}
@ENDNODE

@NODE MainCONTROL "amigaguide.library"
@NEXT MainCONTROL
@{jcenter}@{" A " LINK Main 0}@{" C " LINK MainC 0}@{" G " LINK MainG 0}@{" L " LINK MainL 0}@{" O " LINK MainO 0}@{" R " LINK MainR 0}@{" S " LINK MainS 0}@{" U " LINK MainU 0}@{" OTHER " LINK MainOTHER 0}@{b} CONTROL @{ub}
@{jcenter}
@{u}@{b}amigaguide.library@{uu}@{ub}
@{jleft}@{lindent 1}
@{b}CONTROL@{ub}@{lindent 4}
@{" Controls inside document " LINK "AmigaGuide_Sample.guide/Main"}
@ENDNODE

@NODE "AddAmigaGuideHostA" "amigaguide.library/AddAmigaGuideHostA()"
@PREV AddAmigaGuideHostA
@{jcenter}
@{u}@{b}AddAmigaGuideHostA@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
AddAmigaGuideHostA - Add a dynamic node host.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
handle = AddAmigaGuideHostA (hook, name, attrs);
d0                           a0    d0    a1

@{"AMIGAGUIDEHOST" LINK "libraries/amigaguide.h/MAIN" 169} AddAmigaGuideHostA (struct @{"Hook" LINK "utility/hooks.h/MAIN"} *, STRPTR, struct @{"TagItem" LINK "utility/tagitem.h/MAIN" 34} *);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function adds a callback hook to the dynamic node list.

A dynamic node allows an application to incorporate context-sensitive or live project data within their help system.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
hook - The callback hook.
name - Name of the @{"AmigaGuideHost" LINK "libraries/amigaguide.h/MAIN" 169} database that you are adding. The name must be unique.
attrs - Additional attributes.  None are defined at this time.
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
Returns NULL if unable to add the dynamic node host, otherwise returns a pointer to a handle that will eventually be passed to RemoveAmigaGuideHost() to remove the dynamic node host from the list.
@{lindent 4}
@{fg shine}@{b}NOTES@{lindent 8}@{ub}@{fg text}
When AmigaGuide attempts to resolve a LINK command, it performs the following sequence of events.

Splits the name into a path, a database and a node (only the node is required).
Opens the database.
Performs the following searches until the node is found:
  Search the local database.
  Search the local cross reference list.
  Search the local dynamic node host.
  Search the global help file (system help).
  Search the global cross reference list.
  Search the global dynamic node hosts.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"RemoveAmigaGuideHostA()" LINK "RemoveAmigaGuideHostA" 0}
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{lindent 8}@{ub}@{fg text}

/* Hook dispatcher */
ULONG __asm hookEntry(
        register __a0 struct @{"Hook" LINK "utility/hooks.h/MAIN"} *h,
        register __a2 VOID *obj,
        register __a1 VOID *msg)
{
    /* Pass the parameters on the stack */
    return ((h->h_SubEntry)(h, obj, msg));
}

ULONG __saveds
dispatchAmigaGuideHost (struct @{"Hook" LINK "utility/hooks.h/MAIN"} *h, STRPTR db, Msg msg)
{
    struct @{"opNodeIO" LINK "libraries/amigaguide.h/MAIN" 198} *onm = (struct @{"opNodeIO" LINK "libraries/amigaguide.h/MAIN" 198} *) msg;
    ULONG retval = 0;

    switch (msg->MethodID)
    {
        /* Does this node belong to you? */
        case HM_FINDNODE:
            {
                struct @{"opFindHost" LINK "libraries/amigaguide.h/MAIN" 186} *ofh = (struct @{"opFindHost" LINK "libraries/amigaguide.h/MAIN" 186} *) msg;

                kprintf("Find [%s] in %sn", ofh->ofh_Node, db);

                /* Return TRUE to indicate that it's your node,
                 * otherwise return FALSE. */
                retval = TRUE;
            }
            break;

        /* Open a node. */
        case HM_OPENNODE:
            kprintf("Open [%s] in %sn", onm->onm_Node, db);

            /* Provide the contents of the node */
            onm->onm_DocBuffer = TEMP_NODE;
            onm->onm_BuffLen   = strlen(TEMP_NODE);

            /* Indicate that we were able to open the node */
            retval = TRUE;
            break;

        /* Close a node, that has no users. */
        case HM_CLOSENODE:
            kprintf("Close [%s] in %sn", onm->onm_Node, db);

            /* Indicate that we were able to close the node */
            retval = TRUE;
            break;

        /* Free any extra memory */
        case HM_EXPUNGE:
            kprintf("Expunge [%s]n", db);
            break;

        default:
            kprintf("Unknown method %ldn", msg->MethodID);
            break;
    }

    return (retval);
}

main(int argc, char **argv)
{
    struct @{"Hook" LINK "utility/hooks.h/MAIN"} hook;
    @{"AMIGAGUIDEHOST" LINK "libraries/amigaguide.h/MAIN" 169} hh;

    /* Open the library */
    if (AmigaGuideBase = @{"OpenLibrary" LINK "exec.guide/OpenLibrary" 0}("amigaguide.library", 33))
    {
        /* Initialize the hook */
        hooks.h_Entry    = hookEntry;
        hooks.h_SubEntry = dispatchAmigaGuideHost;

        /* Add the @{"AmigaGuideHost" LINK "libraries/amigaguide.h/MAIN" 169} to the system */
        if (hh = AddAmigaGuideHost(&hook, "ExampleHost", NULL))
        {
            /* Wait until we're told to quit */
            @{"Wait" LINK "exec.guide/Wait" 0}(SIGBREAKF_CTRL_C);

            /* Try removing the host */
            while (RemoveAmigaGuideHost(hh, NULL) > 0)
            {
                /* Wait a while */
                @{"Delay" LINK "dos.guide/Delay" 0}(5);
            }
        }

        /* close the library */
        @{"CloseLibrary" LINK "exec.guide/CloseLibrary" 0}(AmigaGuideBase);
    }
}
@{lindent 4}
@{fg shine}@{b}BUGS@{lindent 8}@{ub}@{fg text}
When a dynamic node host is first added it will receive a HM_FINDNODE message with an onm_Node of "Main". The AGA_HelpGroup attribute will always be zero for this particular message.

@ENDNODE

@NODE "AmigaGuideSignal" "amigaguide.library/AmigaGuideSignal()"
@{jcenter}
@{u}@{b}AmigaGuideSignal()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
AmigaGuideSignal - Obtain aysnc AmigaGuide signal.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
signal = AmigaGuideSignal ( handle );
d0                          a0

ULONG AmigaGuideSignal (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84});
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function returns the signal bit to Wait on for @{"AmigaGuideMsg" LINK "libraries/amigaguide.h/MAIN" 86}'s for a particular AmigaGuide database.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle  - Handle to a AmigaGuide system.
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{lindent 8}@{ub}@{fg text}
ULONG sigw, sigh;
@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} handle;

/* get the signal bit to wait on for a AmigaGuide message */
sigh = AmigaGuideSignal(handle);

/* add the signal bit into the total signals to wait on */
sigw |= sigh;
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
signal  - Signal bit to Wait on.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"OpenAmigaGuideAsyncA()" LINK "OpenAmigaGuideAsyncA" 0}, @{"GetAmigaGuideMsg()" LINK "GetAmigaGuideMsg" 0}, @{"ReplyAmigaGuideMsg()" LINK "ReplyAmigaGuideMsg" 0}
@ENDNODE

@NODE "CloseAmigaGuide" "amigaguide.library/CloseAmigaGuide()"
@{jcenter}
@{u}@{b}CloseAmigaGuide()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
CloseAmigaGuide - Close a AmigaGuide client.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
CloseAmigaGuide (handle);
                 a0

VOID CloseAmigaGuide (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84});
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
Closes a synchronous, or asynchronous, AmigaGuide client.

This function will also close all windows that were opened for the client.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle - Handle to an AmigaGuide client.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"OpenAmigaGuideA()" LINK "OpenAmigaGuideA" 0}, @{"OpenAmigaGuideAsyncA()" LINK "OpenAmigaGuideAsyncA" 0}
@ENDNODE

@NODE "GetAmigaGuideAttr" "amigaguide.library/GetAmigaGuideAttr()"
@{jcenter}
@{u}@{b}GetAmigaGuideAttr()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
GetAmigaGuideAttr - Get an AmigaGuide attribute.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
retval = GetAmigaGuideAttr (tag, handle, storage);
d0                          d0   a0      a1

LONG GetAmigaGuideAttr (Tag, @{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, ULONG *);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to obtain attributes from AmigaGuide.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
tag - Attribute to obtain.
handle - Handle to an AmigaGuide system.
storage - Pointer to appropriate storage for the answer.
@{lindent 4}
@{"TAGS" LINK "utility/tagitem.h/MAIN"}@{lindent 8}
AGA_Path (BPTR) - Pointer to the current path used by AmigaGuide.

AGA_XRefList (struct @{"List" LINK "exec/lists.h/MAIN" 19} *) - Pointer to the current cross reference list.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"SetAmigaGuideAttrsA()" LINK "SetAmigaGuideAttrsA" 0}
@ENDNODE

@NODE "GetAmigaGuideMsg" "amigaguide.library/GetAmigaGuideMsg()"
@{jcenter}
@{u}@{b}GetAmigaGuideMsg()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
GetAmigaGuideMsg - Receive async AmigaGuide message.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
msg = GetAmigaGuideMsg (handle);
d0                       a0

struct @{"AmigaGuideMsg" LINK "libraries/amigaguide.h/MAIN" 86} *GetAmigaGuideMsg (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84});
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function returns a SIPC message from the AmigaGuide system,
if there is a message available.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle - Handle to a AmigaGuide system.
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{lindent 8}@{ub}@{fg text}

@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} handle;
struct @{"AmigaGuideMsg" LINK "libraries/amigaguide.h/MAIN" 86} *agm;

/* get a AmigaGuide message */
while (agm = GetAmigaGuideMsg(handle))
{
    /* process the event */
    switch (agm->agm_Type)
    {
        case ToolCmdReplyID:    /* a command has completed */
            if (agm->agm_Pri_Ret)
            {
                /* An error occurred, the reason is in agm_Sec_Ret.
                 * The command string is in agm_Data
                 */
            }
            break;

        case ToolStatusID:      /* status message */
            if (agm->agm_Pri_Ret)
            {
                /* an error occurred, the reason is in agm_Sec_Ret */
            }
            break;

        default:
            break;
    }

    /* reply to the AmigaGuide message */
    @{"ReplyAmigaGuideMsg" LINK "ReplyAmigaGuideMsg" 0}(agm);
}
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
msg - Pointer to a SIPC message or NULL if no message was available.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"OpenAmigaGuideAsyncA()" LINK "OpenAmigaGuideAsyncA" 0}, @{"AmigaGuideSignal()" LINK "AmigaGuideSignal" 0}, @{"ReplyAmigaGuideMsg()" LINK "ReplyAmigaGuideMsg" 0}
@ENDNODE

@NODE "GetAmigaGuideString" "amigaguide.library/GetAmigaGuideString()"
@{jcenter}
@{u}@{b}GetAmigaGuideString()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
GetAmigaGuideString - Get an AmigaGuide string.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
txt = GetAmigaGuideString (id);
d0                         d0

STRPTR GetAmigaGuideString (ULONG);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to obtain a localized string given the ID.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
ID -- Valid AmigaGuide string id.
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
A pointer to the string.   NULL for an invalid string.
@ENDNODE

@NODE "LockAmigaGuideBase" "amigaguide.library/LockAmigaGuideBase()"
@{jcenter}
@{u}@{b}LockAmigaGuideBase()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
LockAmigaGuideBase - Lock an AmigaGuide client.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
key = LockAmigaGuideBase (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} handle);
                          a0

LONG LockAmigaGuideBase (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84});
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to lock the AmigaGuide context handle while working with data obtained with the the @{"GetAmigaGuideAttr()" LINK "GetAmigaGuideAttr" 0} function.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle - @{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} handle obtained with OpenAmigaGuideAsync().
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
Returns a key to pass to @{"UnlockAmigaGuideBase()" LINK "UnlockAmigaGuideBase" 0}.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"UnlockAmigaGuideBase()" LINK "UnlockAmigaGuideBase" 0}
@ENDNODE

@NODE "OpenAmigaGuideA" "amigaguide.library/OpenAmigaGuideA()"
@{jcenter}
@{u}@{b}OpenAmigaGuideA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
OpenAmigaGuideA - Open a synchronous AmigaGuide database.
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
handle = OpenAmigaGuideA (nag, attrs);
d0                        a0   a1

@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} OpenAmigaGuideA (struct @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} *, struct @{"TagItem" LINK "utility/tagitem.h/MAIN"} *);

handle = OpenAmigaGuide (nag, tag1, ...);

@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} OpenAmigaGuide (struct @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} *, Tag tag1, ...);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
Opens a AmigaGuide database, complete with the first viewing window, for synchronous activity.

Before you call OpenAmigaGuide(), you must initialize a @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} structure. @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} is a structure that contains all the information needed to open a database. The @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} structure must be retained until the call returns.

The function will not return until the user closes all the windows.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
nag - Pointer to an instance of a @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} structure. That structure is initialized with the following data.
nag_Lock
Lock on the directory that the database is located in. Not needed if nag_Name contains the complete path name.

nag_Name
Name of the AmigaGuide database.

nag_Screen
Screen to open the viewing windows on, NULL for the Workbench screen.

nag_PubScreen
Pointer to the name of the public screen to open on. Must already be opened.

nag_HostPort
Name of the applications' ARexx port (currently not used).

nag_ClientPort
Base name to use for the databases' ARexx port.

nag_Flags
Used to specify the requirements of this database. The flags are defined in <@{"libraries/amigaguide.h" LINK "libraries/amigaguide.h/MAIN" 0}>.

nag_Context
NULL terminated array of context nodes, in the form of:
@{lindent 12}
/* context array */
STRPTR context[] =
{
    "MAIN",
    "INTRO",
    "GADGETS",
    NULL
};
@{lindent 8}
The context array is not copied, but referenced, therefore must remain static throughout the useage of the AmigaGuide system. This array is only referenced when using the SetAmigaGuideContext() function.

nag_Node
Node to start at (does not work with OpenAmigaGuideAsync()).

nag_Line
Line to start at (does not work with OpenAmigaGuideAsync()).

nag_Extens
Used by @{FG SHINE}V37@{FG TEXT} and beyond to pass additional arguments.

nag_Client
This is a private pointer, MUST be initialized to NULL.
@{lindent 8}
attrs - Additional attributes.
@{lindent 4}
@{"TAGS" LINK "utility/tagitem.h/MAIN"}@{lindent 8}
AGA_HelpGroup (ULONG) -- Unique identifier used to identify the AmigaGuide help windows. See @{"OpenWindow()" LINK "intuition.guide/OpenWindow" 0} and @{"GetUniqueID()" LINK "utility.guide/GetUniqueID" 0}.
@{lindent 16}
Default for this tag is NULL.  Applicability is (I).  @{FG SHINE}(V39)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{ub}@{fg text}
@{lindent 8}
/* Short example showing synchronous AmigaGuide access */
LONG ShowAmigaGuideFile (STRPTR name, STRPTR node, LONG line)
{
    struct @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} nag = {NULL};
    @{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} handle;
    LONG retval = 0L;

    /* Fill in the @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} structure */
    nag.nag_Name = name;
    nag.nag_Node = node;
    nag.nag_Line = line;

    /* Open the AmigaGuide client */
    if ( handle = OpenAmigaGuide(&nag, NULL))
    {
        /* Close the AmigaGuide client */
        @{"CloseAmigaGuide" LINK "CloseAmigaGuide" 0}(handle);
    }
    else
    {
        /* Get the reason for failure */
        retval = @{"IoErr()" LINK "dos.guide/IoErr" 0};
    }

    return (retval);
}
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
handle - Handle to a AmigaGuide system.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"OpenAmigaGuideAsyncA()" LINK "OpenAmigaGuideAsyncA" 0}, @{"CloseAmigaGuide()" LINK "CloseAmigaGuide" 0}
@ENDNODE

@NODE "OpenAmigaGuideAsyncA" "amigaguide.library/OpenAmigaGuideAsyncA()"
@{jcenter}
@{u}@{b}OpenAmigaGuideAsyncA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
OpenAmigaGuideAsyncA - Open an AmigaGuide database async  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
handle = OpenAmigaGuideAsyncA (nag, attrs);
d0                             a0   d0

@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} OpenAmigaGuideAsyncA (struct @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} *, struct @{"TagItem" LINK "utility/tagitem.h/MAIN"} *);

handle = OpenAmigaGuideAsync (nag, tag1, ...);

@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84} OpenAmigaGuideAsyncA (struct @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} *, Tag tag1, ...);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
Opens an AmigaGuide database for ansynchronous use.

The @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} structure, and its pointers, must stay valid until an ActiveToolID or ToolStatusID message is received by the calling process.

This function actually spawns OpenAmigaGuide() as another process, so, for further documentation, refer to the OpenAmigaGuide() function.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
@{lindent 18}nag     - Pointer to a valid @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} structure. (see OpenAmigaGuide() for documentation on its useage).
@{lindent 8}
attrs   - Additional attributes.  See @{"OpenAmigaGuideA()" LINK "OpenAmigaGuideA" 0}.
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
handle  - Handle to an AmigaGuide system.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"OpenAmigaGuideA()" LINK "OpenAmigaGuideA" 0}, @{"CloseAmigaGuide()" LINK "CloseAmigaGuide" 0}
@ENDNODE

@NODE "RemoveAmigaGuideHostA" "amigaguide.library/RemoveAmigaGuideHostA()"
@{jcenter}
@{u}@{b}RemoveAmigaGuideHostA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
RemoveAmigaGuideHostA - Remove a dynamic node host.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
use = RemoveAmigaGuideHostA (key, attrs)
d0                           a0   a1

LONG RemoveAmigaGuideHostA (@{"AMIGAGUIDEHOST" LINK "libraries/amigaguide.h/MAIN" 169}, struct @{"TagItem" LINK "utility/tagitem.h/MAIN"} *);

use = RemoveAmigaGuideHost (key, tag1, ...);

LONG RemoveAmigaGuideHost (@{"AMIGAGUIDEHOST" LINK "libraries/amigaguide.h/MAIN" 169}, Tag, ...);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function removes a dynamic node host, that was added by AddAmigaGuideHost(), from the system.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
key - Key that was returned by AddAmigaGuideHost().

attrs - Additional attributes.  None are defined at this time.
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
use - Number of outstanding clients of this database. You can not exit until use==0.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"AddAmigaGuideHostA()" LINK "AddAmigaGuideHostA" 0}
@ENDNODE

@NODE "ReplyAmigaGuideMsg" "amigaguide.library/ReplyAmigaGuideMsg()"
@{jcenter}
@{u}@{b}ReplyAmigaGuideMsg()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
ReplyAmigaGuideMsg - Reply to an AmigaGuide message.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
ReplyAmigaGuideMsg ( msg );
                     a0

VOID ReplyAmigaGuideMsg (struct @{"AmigaGuideMsg" LINK "libraries/amigaguide.h/MAIN" 86} *msg);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to reply to an AmigaGuide SIPC message.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
@{lindent 14}msg - Pointer to a SIPC message returned by a previous call to @{"GetAmigaGuideMsg()" LINK "GetAmigaGuideMsg" 0}.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"OpenAmigaGuideAsyncA()" LINK "OpenAmigaGuideAsyncA" 0}, @{"AmigaGuideSignal()" LINK "AmigaGuideSignal" 0}, @{"GetAmigaGuideMsg()" LINK "GetAmigaGuideMsg" 0}
@ENDNODE

@NODE "SendAmigaGuideCmdA" "amigaguide.library/SendAmigaGuideCmdA()"
@{jcenter}
@{u}@{b}SendAmigaGuideCmdA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
SendAmigaGuideCmdA - Send a command string to AmigaGuide  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
success = SendAmigaGuideCmdA ( handle, cmd, attrs );
d0                             a0      d0   d1

BOOL SendAmigaGuideCmdA (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, STRPTR, struct @{"TagItem" LINK "utility/tagitem.h/MAIN" 34} *);

success = SendAmigaGuideCmd (handle, cmd, tag1, ...);

BOOL SendAmigaGuideCmd (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, STRPTR, Tag);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function sends a command string to an AmigaGuide system. The command can consist of any valid AmigaGuide action command.

The following are the currently valid action commands:

ALINK <name> - Load the named node into a new window.

LINK <name> - Load the named node.

RX <macro> - Execute an ARexx macro.

@{lindent 20}RXS <cmd> - Execute an ARexx string file.  To display a picture, use 'ADDRESS COMMAND DISPLAY <picture name>', to display a text file 'ADDRESS COMMAND MORE <doc>'.
@{lindent 8}
@{lindent 16}CLOSE - Close the window (should only be used on windows that were started with ALINK).
@{lindent 8}
QUIT - Shutdown the current database.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle - Handle to an AmigaGuide system.

cmd - Command string.

attrs - Future expansion, must be set to NULL for now.
@{lindent 4}
@{"TAGS" LINK "utility/tagitem.h/MAIN"}@{lindent 8}
@{lindent 30}AGA_Context (ULONG) - Data is used as an index into nag_Context array. This is used to build and send a LINK command.
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{lindent 8}@{ub}@{fg text}

/* bring up help on a particular subject */
SendAmigaGuideCmd(handle, "LINK MAIN", NULL);
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
Returns TRUE if the message was sent, otherwise returns FALSE.
@{lindent 4}
@{fg shine}@{b}BUGS@{lindent 8}@{ub}@{fg text}
ALINK does not open a new window when using @{FG SHINE}V39@{FG TEXT}.
@ENDNODE

@NODE "SendAmigaGuideContextA" "amigaguide.library/SendAmigaGuideContextA()"
@{jcenter}
@{u}@{b}SendAmigaGuideContextA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
SendAmigaGuideContextA - Align an AmigaGuide system on the context ID.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
success = SendAmigaGuideContextA (handle, attrs);
d0                                a0      d0

BOOL SendAmigaGuideContextA (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, struct @{"TagItem" LINK "utility/tagitem.h/MAIN"} *);

success = SendAmigaGuideContext (handle, tag1, ...);

BOOL SendAmigaGuideContext (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, Tag, ...);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to send a message to an AmigaGuide system to align it on the current context ID.

This function effectively does a:
@{lindent 12}
SendAmigaGuideCmd(handle 'LINK ContextArray[contextID]', NULL);
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle - Handle to an AmigaGuide system.
future - Future expansion, must be set to NULL for now.
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{lindent 8}@{ub}@{fg text}

struct @{"IntuiMessage" LINK "intuition/intuition.h/MAIN" 763} *imsg;

...

case RAWKEY:
    switch (imsg->Code)
    {
        case 95:
            /* bring up help on a particular subject */
            SendAmigaGuideContext(handle, NULL);
            break;
        ...
    }
    break;

...
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
success - Returns TRUE if the message was sent, otherwise returns FALSE.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"SetAmigaGuideContextA()" LINK "SetAmigaGuideContextA" 0}, @{"SendAmigaGuideCmdA()" LINK "SendAmigaGuideCmdA" 0}
@ENDNODE

@NODE "SetAmigaGuideAttrsA" "amigaguide.library/SetAmigaGuideAttrsA()"
@{jcenter}
@{u}@{b}SetAmigaGuideAttrsA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
SetAmigaGuideAttrsA - Set an AmigaGuide attribute.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
retval = SetAmigaGuideAttrsA (handle, attrs);
d0                            a0      a1

LONG SetAmigaGuideAttrsA (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, struct @{"TagItem" LINK "utility/tagitem.h/MAIN"} *);

retval = SetAmigaGuideAttrs (handle, tag1, ...);

LONG SetAmigaGuideAttrs (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, Tag, ...);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to set AmigaGuide attributes.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle  - Pointer to an AmigaGuide handle.

attrs   - Attribute pairs to set.
@{lindent 4}
@{"TAGS" LINK "utility/tagitem.h/MAIN"}@{lindent 8}
AGA_Activate (BOOL) - AmigaGuide activates the window when it receives a LINK command. This tag allows the application developer to turn that feature off and on.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"GetAmigaGuideAttr()" LINK "GetAmigaGuideAttr" 0}
@ENDNODE

@NODE "SetAmigaGuideContextA" "amigaguide.library/SetAmigaGuideContextA()"
@{jcenter}
@{u}@{b}SetAmigaGuideContextA()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
SetAmigaGuideContextA - Set the context ID for an AmigaGuide system.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
success = SetAmigaGuideContextA ( handle, context, attrs );
d0                                a0      d0       d1

BOOL SetAmigaGuideContextA (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, ULONG, struct @{"TagItem" LINK "utility/tagitem.h/MAIN"} *);

success = SetAmigaGuideContext (handle, context, tag1, ...);

BOOL SetAmigaGuideContext (@{"AMIGAGUIDECONTEXT" LINK "libraries/amigaguide.h/MAIN" 84}, ULONG, Tag, ...);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function, and the SendAmigaGuideContext() function, are used to provide a simple way to display a node based on a numeric value, instead of having to build up a slightly more complex command string.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
handle  - Handle to an AmigaGuide system.

context - Index value of the desired node to display.

future  - Future expansion, must be set to NULL for now.
@{lindent 4}
@{fg shine}@{b}EXAMPLE@{lindent 8}@{ub}@{fg text}

/* sample context table */
STRPTR ContextArray[] =
{
    "MAIN",
    "FILEREQ",
    "PRINT",
    "ABOUT",
    NULL
};

/* quickie defines */
#define HELP_MAIN       0
#define HELP_FILEREQ    1
#define HELP_PRINT      2
#define HELP_ABOUT      3

...

struct @{"NewAmigaGuide" LINK "libraries/amigaguide.h/MAIN" 100} nag = {NULL};

/* initialize the context table */
nag.nag_Context = ContextArray;

...

/* bring up help on a particular subject */
SetAmigaGuideContext(handle, HELP_ABOUT, NULL);
@{lindent 4}
@{fg shine}@{b}RETURNS@{lindent 8}@{ub}@{fg text}
success - Returns TRUE if a valid context ID was passed, otherwise returns FALSE.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"SendAmigaGuideContextA()" LINK "SendAmigaGuideContextA" 0}, @{"SendAmigaGuideCmdA()" LINK "SendAmigaGuideCmdA" 0}
@ENDNODE

@NODE "UnlockAmigaGuideBase" "amigaguide.library/UnlockAmigaGuideBase()"
@{jcenter}
@{u}@{b}UnlockAmigaGuideBase()@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}NAME@{lindent 8}@{ub}@{fg text}
UnlockAmigaGuideBase - Unlock an AmigaGuide client.  @{FG SHINE}(V34)@{FG TEXT}
@{lindent 4}
@{fg shine}@{b}SYNOPSIS@{lindent 8}@{ub}@{fg text}
UnlockAmigaGuideBase (key);
                      d0

VOID UnlockAmigaGuideBase (LONG);
@{lindent 4}
@{fg shine}@{b}FUNCTION@{lindent 8}@{ub}@{fg text}
This function is used to release a lock obtained with @{"LockAmigaGuideBase()" LINK "LockAmigaGuideBase" 0}.
@{lindent 4}
@{fg shine}@{b}INPUTS@{lindent 8}@{ub}@{fg text}
key - Value returned by @{"LockAmigaGuideBase()" LINK "LockAmigaGuideBase" 0}.
@{lindent 4}
@{fg shine}@{b}SEE ALSO@{lindent 8}@{ub}@{fg text}
@{"LockAmigaGuideBase()" LINK "LockAmigaGuideBase" 0}.
@ENDNODE

@NODE "--background--" "amigaguide.library/--background--"
@{jcenter}
@{u}@{b}--background--@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}PURPOSE@{ub}@{fg text}@{lindent 8}
The amigaguide.library provides a means whereby developers can easily add on-line help abilities to their applications.
@ENDNODE

@NODE "--rexxhost--" "amigaguide.library/--rexxhost--"
@{jcenter}
@{u}@{b}--rexxhost--@{uu}@{ub}
@{jleft}@{lindent 4}
@{fg shine}@{b}HOST INTERFACE@{ub}@{fg text}@{lindent 8}
amigaguide.library provides an ARexx function host interface that enables ARexx programs to take advantage of the features of AmigaGuide. The functions provided by the interface are directly related to the functions described herein, with the differences mostly being in the way they are called.

The function host library vector is located at offset -30 from the library. This is the value you provide to ARexx in the AddLib() function call.
@{lindent 4}
@{fg shine}@{b}FUNCTIONS@{lindent 8}@{ub}@{fg text}
ShowNode (PUBSCREEN,DATABASE,NODE,LINE,XREF)

LoadXRef (NAME)

GetXRef (NODE)
@ENDNODE