home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / h / hldevkit.zip / HOTLINKS.DOC < prev    next >
Text File  |  1992-04-28  |  29KB  |  879 lines
  1.  
  2.  
  3. TABLE OF CONTENTS
  4.  
  5. hotlinks.library/HLSysInfo
  6. hotlinks.library/HLRegister
  7. hotlinks.library/UnRegister
  8. hotlinks.library/AllocPBlock
  9. hotlinks.library/FreePBlock
  10. hotlinks.library/SetUser
  11. hotlinks.library/ChgPassword
  12. hotlinks.library/FirstPub
  13. hotlinks.library/NextPub
  14. hotlinks.library/RemovePub
  15. hotlinks.library/Notify
  16. hotlinks.library/PubStatus
  17. hotlinks.library/GetInfo
  18. hotlinks.library/SetInfo
  19. hotlinks.library/LockPub
  20. hotlinks.library/OpenPub
  21. hotlinks.library/ReadPub
  22. hotlinks.library/WritePub
  23. hotlinks.library/SeekPub
  24. hotlinks.library/ClosePub
  25. hotlinks.library/GetPub
  26. hotlinks.library/PutPub
  27. hotlinks.library/PubInfo
  28. hotlinks.library/NewPassword
  29.  
  30.  
  31. hotlinks.library/HLSysinfo                           hotlinks.library/HLSysInfo
  32.     NAME
  33.     HLSysInfo - obtain information regarding the hotlinks system.
  34.  
  35.     SYNOPSIS
  36.     error = HLSysInfo(handle, array)
  37.      d0              d0      d1
  38.  
  39.     int HLSysInfo(ULONG, int *);
  40.  
  41.     FUNCTION
  42.         Will fill array with useful information like memory used, number of 
  43.         editions, etc. The exact information to be returned has not been
  44.         decided yet.
  45.         
  46.         This routine is not yet implemented so it will return UNIMPLEMENTED.
  47.  
  48.     INPUTS
  49.         handle - the hotlinks 'handle' as returned by HLRegister.
  50.         
  51.         array - an array of long words that will be filled in by the routine.
  52.                 The exact format of this array has not been decided yet, other
  53.                 than to say that it will be an array of long words. But exactly
  54.                 how many entries are needed and what they each stand for has
  55.                 yet to be determined.
  56.  
  57.     RESULTS
  58.         Will fill in the array with information about the hotlinks system.
  59.         
  60.         Possible information includes:                
  61.                 user name
  62.                 hotlinks resident code version number
  63.                 number of local editions
  64.                 number of remote editions
  65.                 number of programs registered with hotlinks
  66.                 memory used by hotlinks
  67.  
  68.     BUGS
  69.         None.
  70.  
  71.  
  72. hotlinks.library/HLRegister                         hotlinks.library/HLRegister
  73.     NAME
  74.        HLRegister - register a program with the hotlinks system.
  75.     
  76.     SYNOPSIS
  77.         handle = HLRegister(id, msgport, screen)
  78.           d0                d0    d1       d2
  79.         
  80.         ULONG HLRegister(int, struct MsgPort *, struct Screen *);
  81.  
  82.     FUNCTION
  83.         Program must make this call to register themselves with HotLinks 
  84.         prior to making any calls to hotlinks.
  85.         
  86.         Handle must be freed before the registered program exits or memory
  87.         will be lost.
  88.  
  89.     INPUTS
  90.         id - a four byte id to be used for as the creator id of any editions
  91.            that this application may create.
  92.            
  93.         msgport - a pointer to a standard exec message port. This port is used
  94.            to send Notify messages to the application when an edition changes. 
  95.            This may be NULL, if the application never calls Notify() to set up 
  96.            a notify on an edition.
  97.            
  98.         screen - a pointer to a valid screen where to application wants
  99.            hotlinks to open up it's requester on. If this argument is NULL
  100.            the default public screen is chosen (which is normally Workbench).
  101.  
  102.     RESULTS
  103.         handle - a handle to be maintained throughout the duration of the
  104.            registered application.  This must be freed by calling UnRegister()
  105.            before the application exits or memory will be lost.
  106.            
  107.         INVPARAM - ?
  108.         NOMEMORY - there was not enough memory to perform this function.
  109.  
  110.     SEE ALSO
  111.         UnRegister()
  112.         
  113.     BUGS
  114.         None.
  115.  
  116.  
  117. hotlinks.library/UnRegister                         hotlinks.library/UnRegister
  118.     NAME    
  119.         UnRegister - used to unregister an application with hotlinks.
  120.         
  121.     SYNOPSIS
  122.         error = UnRegister(handle)
  123.          d0                 d0
  124.         
  125.         int UnRegister(ULONG);
  126.  
  127.     FUNCTION
  128.         This call is used to free the handle allocated by HLRegister(). This
  129.         routine must be called before the registered application exits or
  130.         memory will be lost.
  131.  
  132.     INPUTS
  133.         handle - must be a valid handle returned from HLRegister().
  134.     
  135.     RESULTS
  136.         NOERROR - if everything is OK.
  137.         ?
  138.  
  139.     SEE ALSO
  140.         HLRegister()
  141.     
  142.     BUGS
  143.         None.
  144.         
  145.  
  146. hotlinks.library/AllocPBlock                       hotlinks.library/AllocPBlock
  147.     NAME
  148.         AllocPBlock - allocate a publication block.
  149.     
  150.     SYNOPSIS
  151.         pblock = AllocPBlock(handle)
  152.           d0                   d0
  153.         
  154.         struct PubBlock *AllocPBlock(ULONG);
  155.  
  156.     FUNCTION
  157.         This function will allocate a struct PubBlock and initialize it.
  158.         This is the preferred method of allocating a PubBlock structure because
  159.         if the size of the PubBlock structure changes your program will not
  160.         have to be changed to work properly.
  161.         
  162.     INPUTS
  163.         handle - must be a valid handle as returned by HLRegister().
  164.  
  165.     RESULTS
  166.         pblock - points to a valid initialized PubBlock struct.
  167.         
  168.         NOMEMORY - not enough memory to allocate a PubBlock struct.
  169.         INVPARAM - the handle was invalid.
  170.  
  171.     SEE ALSO
  172.         FreePBlock(), HLRegister()
  173.         
  174.     BUGS
  175.         None.
  176.  
  177.  
  178. hotlinks.library/FreePBlock                         hotlinks.library/FreePBlock
  179.     NAME
  180.         FreePBlock - frees a publication block obtained by AllocPBlock().
  181.     
  182.     SYNOPSIS
  183.         error = FreePBLock(pblock)
  184.          d0                  d0
  185.          
  186.         int FreePBlock(struct PubBlock *);
  187.  
  188.     FUNCTION
  189.         This will free the memory allocated by AllocPBlock() pointed to by
  190.         pblock.
  191.     
  192.     INPUTS
  193.         pblock - must point to a valid PubBlock struct as returned by
  194.             AllocPBlock().
  195.  
  196.     RESULTS
  197.         INVPARAM - if the pblock was not a valid PubBlock pointer (NULL
  198.             for example).
  199.  
  200.     SEE ALSO
  201.         AllocPBlock()
  202.         
  203.     BUGS
  204.         None.
  205.         
  206.  
  207. hotlinks.library/SetUser                               hotlinks.library/SetUser
  208.     NAME   
  209.         SetUser - sets the current user on the hotlinks system.
  210.     
  211.     SYNOPSIS
  212.         error = SetUser(handle, name, password);
  213.          d0              d0      a0     a1
  214.         int SetUser(ULONG, char *, char *);
  215.         
  216.     FUNCTION
  217.         Will set the current user to Name, if Password is valid for Name's 
  218.         account.
  219.  
  220.     INPUTS
  221.         handle - must be a valid handle as returned by HLRegister().
  222.         name - a pointer to a NULL terminated string or NULL.
  223.         password - a pointer to a NULL terminated string or NULL.
  224.         
  225.         If both the name and password are NULL then the current user is
  226.         logged off the system. The next time a call to hotlinks is made the
  227.         login prompt will be presented.
  228.     
  229.     RESULTS
  230.         INVPARAM - if password is not valid for name.
  231.  
  232.     SEE ALSO
  233.         HLRegister()
  234.         
  235.     BUGS
  236.         None.
  237.         
  238.  
  239. hotlinks.library/ChgPassword                       hotlinks.library/ChgPassword
  240.     NAME  
  241.         ChgPassword - allows the changing of a users password.
  242.  
  243.     SYNOPSIS
  244.         Error = ChgPassword(handle, name, oldpwd, newpwd);
  245.          d0                   d0     a0       a1            a2
  246.   
  247.         int ChgPassword(ULONG, char *, char *, char *);
  248.  
  249.     FUNCTION
  250.         Changes the password of <name> from <oldpwd> to <newpwd>.
  251.  
  252.     INPUTS
  253.         name - a pointer to a NULL terminated string.
  254.         oldpwd - a pointer to a NULL terminated string.
  255.         newpwd - a pointer to a NULL terminated string.
  256.         
  257.         All values must be valid and not NULL, unless the current user is
  258.         the superuser. As superuser, one must only supply the name and
  259.         newpwd to change a regular user's password. If the superuser wants to
  260.         change the superuser's password then all parameters must be valid and
  261.         not NULL.
  262.         
  263.         The arguments need not be kept around for the duration of the program.
  264.         The hotlinks resident code makes copies of the strings.
  265.  
  266.     RESULTS
  267.         INVPARAM - the oldpwd was not valid for name, or a parameter was NULL.
  268.         NOPRIV - the current user tried to change another uses password.
  269.         NOMEMORY - not enough memory to allocate the newpwd.
  270.  
  271.     BUGS
  272.         None.
  273.  
  274.  
  275. hotlinks.library/FirstPub                             hotlinks.library/FirstPub
  276.     NAME
  277.         FirstPub - fills in a PubBlock with the first publication's information
  278.     
  279.     SYNOPSIS
  280.         error = FirstPub(pblock)
  281.          d0                d0
  282.          
  283.         int FirstPub(struct PubBlock *);
  284.  
  285.     FUNCTION
  286.         Returns the pblock structure filled in for first available edition.
  287.         This works much like the dos.library Examine call in that it sets
  288.         up for a series os NextPub() calls to look at all the editions the
  289.         current user can gain access to.
  290.  
  291.     INPUTS
  292.         pblock - pointer to a valid PubBlock as returned by AllocPBlock().
  293.  
  294.     RESULTS
  295.         NOERROR - pblock will be filled in with the information for the first
  296.             edition file that the user can gain access to. Note that only the 
  297.             editions that the current user has access to will be peeked by 
  298.             this function all others will be skipped over.
  299.         NOMOREBLOCKS - if there are no editions this user can access or if
  300.             there are no editions at all.
  301.         INVPARAM - if the pblock is invalid or NULL
  302.  
  303.     SEE ALSO
  304.         NextPub()
  305.         
  306.     BUGS
  307.         None.
  308.  
  309.  
  310. hotlinks.library/NextPub                               hotlinks.library/NextPub
  311.     NAME
  312.         NextPub - fills in a pubblock struct with the next pub's information.
  313.                   Valid only after a call to FirstPub().
  314.     
  315.     SYNOPSIS
  316.         Error = NextPub(pblock)
  317.          d0               d0
  318.          
  319.         int NextPub(struct PubBlock *);
  320.  
  321.     FUNCTION
  322.         Returns the pblock structure filled in for the next available edition.
  323.         pblock must be the same pblock that was used in the call to FirstPub()
  324.         or the previous NextPub() call. This routine functions much like the
  325.         dos.library ExNext call. Repeated calls to this function will have
  326.         the result of stepping through each of the available editions available
  327.         to the currently logged in user.
  328.  
  329.     INPUTS
  330.         pblock - must be a valid PubBlock as returned by AllocPBlock() and
  331.             processed by a call to FirstPub() or a previous call to NextPub().
  332.     
  333.     RESULTS
  334.         NOERROR - pblock will be filled in with the information for the next
  335.             edition file that the user can gain access to. Note that only the 
  336.             editions that the current user has access to will be peeked by 
  337.             this function all others will be skipped over.
  338.         NOMOREBLOCKS - there are no more editions available.
  339.         INVPARAM - an invalid pblock was passed.
  340.  
  341.     SEE ALSO
  342.         FirstPub()
  343.         
  344.     BUGS
  345.         None.
  346.         
  347.  
  348. hotlinks.library/RemovePub                           hotlinks.library/RemovePub
  349.     NAME
  350.         RemovePub - delete an edition
  351.     
  352.     SYNOPSIS
  353.         Error = RemovePub(pblock)
  354.          d0                 d0
  355.          
  356.         int RemovePub(struct PubBlock *);
  357.     
  358.     FUNCTION
  359.         Will remove the edition file if the currently logged in user can do so.
  360.         
  361.         If an edition is deleted while applications still have links to it or
  362.         notifies set up on it they will receive errors when those applications
  363.         try to access any hotlinks function with that pblock. Normally this
  364.         error will be INVPARAM.
  365.     
  366.     INPUTS
  367.         pblock - must be a valid PubBlock as returned by AllocPBlock().
  368.             pblock->PRec.ID[0], pblock->PRec.ID[1], and pblock->PRec.Version
  369.             must be valid. The version number must be the latest version
  370.             number or the call will fail.
  371.  
  372.     RESULTS
  373.         INVPARAM - the pblock was NULL or otherwise invalid (the version number
  374.             was not the most recent).
  375.         IOERROR - the dos.library DeleteFile() routine failed.
  376.         CHANGED - ?
  377.  
  378.     BUGS
  379.         None.
  380.  
  381.  
  382. hotlinks.library/Notify                                 hotlinks.library/Notify
  383.     NAME
  384.         Notify - set up a notify node for this application on this edition
  385.  
  386.     SYNOPSIS
  387.         Error = Notify(pblock, flag, class, userdata)
  388.          d0              d0     d1     d2      a0
  389.         
  390.         int Notify(struct PubBlock *, int, int, void *);
  391.  
  392.     FUNCTION
  393.         This will cause a notify to be set up on the pblock. Anytime the
  394.         edition file is changed by any application a message is sent to
  395.         the message port specified in the HLRegister() call telling it so.
  396.         
  397.         The message sent is a struct HLMsg.
  398.  
  399.     INPUTS
  400.         pblock - must point to a valid PubBLock as returned by AllocPBLock().
  401.         flag - 
  402.            INFORM - will set up a link to the edition file during which time
  403.               if the document is changed. A message will be sent to the 
  404.               program indicating a publication has changed (and it's ID) via
  405.               the message port specified in the HLRegister() call.
  406.  
  407.            EXINFORM - will set up a link to the edition file during which
  408.               time if the document is changed. A message will be sent to the
  409.               program indicating a publication has changed (and it's ID) via
  410.               the message port specified in the HLRegister() call. Using this
  411.               flag only 1 notify per edition per message port may be set up.
  412.  
  413.            NOINFORM - will cancel the notify request made on a previous call
  414.               to Notify() with either INFORM or EXINFORM.
  415.  
  416.     RESULTS
  417.         NOERROR - a notify was set up on the edition file.
  418.         INVPARAM - an invalid argument was passed.
  419.         NOMEMORY - not enough memory to set up the notify.
  420.  
  421.     SEE ALSO
  422.         HLRegister()
  423.         
  424.     BUGS
  425.         None.
  426.  
  427.  
  428. hotlinks.library/PubStatus                           hotlinks.library/PubStatus
  429.     NAME
  430.         PubStatus - checks to see if the edition has changed.
  431.         
  432.     SYNOPSIS
  433.         Error = PubStatus(pblock)
  434.          d0                d0
  435.          
  436.         int PubStatus(struct PubBlock *);
  437.  
  438.     FUNCTION
  439.         This will check to see if the edition file has changed from the data
  440.         contained in the pblock passed to it.
  441.         
  442.  
  443.     INPUTS
  444.         pblock - must be a valid PubBlock as returned by AllocPBlock().
  445.            pblock->PRec.ID[0], pblock->PRec.ID[1], and pblock->PRec.Version
  446.            must be valid.
  447.  
  448.     RESULTS
  449.         NOERROR - if the edition has not changed.
  450.         CHANGED - if the edition has changed.
  451.         INVPARAM - if the pblock is invalid or NULL.
  452.         NOPRIV - if the currently logged in user cannot access the edition
  453.             file specified by the pblock.
  454.         
  455.         No values in the pblock are modified by this call.
  456.  
  457.     SEE ALSO
  458.         AllocPBlock()
  459.         
  460.     BUGS
  461.         None.
  462.         
  463.  
  464. hotlinks.library/GetInfo                               hotlinks.library/GetInfo
  465.     NAME
  466.         GetInfo - fills in a pubblock struct with the information for the
  467.                   given id.
  468.     
  469.     SYNOPSIS
  470.         Error = GetInfo(pblock)
  471.          d0               d0
  472.          
  473.         int GetInfo(struct PubBlock *);
  474.  
  475.     FUNCTION
  476.         This function will fill in a PubBlock with all the information for
  477.         the requested edition file.
  478.     
  479.     INPUTS
  480.         pblock - must be a valid PubBlock with the pblock->PRec.ID fields
  481.            filled in for the edition file you want the information for.
  482.  
  483.     RESULTS
  484.         NOERROR - the pblock is filled in with the edition's information.
  485.         INVPARAM - an  invalid or NULL pblock was passed.
  486.         NOPRIV - the currently logged in user does not have access to the 
  487.            requested edition file.
  488.  
  489.     BUGS
  490.         None.
  491.  
  492.  
  493. hotlinks.library/SetInfo                               hotlinks.library/SetInfo
  494.     NAME
  495.         SetInfo - will change the information for the publication to the new
  496.                   information as specified in the setinfo call.
  497.  
  498.     SYNOPSIS
  499.         Error = SetInfo(pblock)
  500.          d0               d0
  501.          
  502.         int SetInfo(struct PubBlock *);
  503.  
  504.     FUNCTION
  505.         This function will reset all fields in the hotlinks internal database
  506.         record for the edition file with the information from the pblock. All
  507.         the fields will be changed to the data specified in the pblock. To
  508.         change only a few fields, first make a call to the GetInfo() routine
  509.         to fill the pblock with all the current information. Then make your
  510.         changes and call SetInfo().
  511.         
  512.     INPUTS
  513.         pblock - must be a valid pblock filled in with the new information.
  514.  
  515.     RESULTS
  516.         INVPARAM - an invalid pblock was passed.
  517.  
  518.     SEE ALSO
  519.         GetInfo()
  520.         
  521.     BUGS
  522.         None.
  523.         
  524.  
  525. hotlinks.library/LockPub                               hotlinks.library/LockPub
  526.     NAME
  527.         LockPub - locks an edition file for read or write access.
  528.     
  529.     SYNOPSIS
  530.         Error = LockPub(pblock, flags)
  531.          d0               d0     d1
  532.          
  533.         int LockPub(struct PubBlock *, int);
  534.  
  535.     FUNCTION
  536.         This function will allow you to lock other applications out from being
  537.         able to modify the edition file until you unlock it.
  538.         
  539.         This is a 'soft' lock in that it is only in effect while the hotlinks
  540.         resident code is active. If the computer is turned off, all locks
  541.         are lost.
  542.  
  543.     INPUTS
  544.         pblock - must be a valid PubBLock.
  545.         flags - 
  546.             LOCK_RELEASE - will release the previously held lock.
  547.             LOCK_READ - locks the edition file for reading. This is not an 
  548.                 exclusive lock. So other applications can also gain read
  549.                 access to this file.
  550.             LOCK_WRITE - locks the edition file for writing. This is an 
  551.                 exclusive lock. No other application can get a lock on the
  552.                 edition file until the lock is released.
  553.  
  554.     RESULTS
  555.         NOERROR - got the lock with no problems.
  556.         INVPARAM - a invalid parameter was passed to the function.
  557.         INUSE - the edition file is locked by some one else.
  558.         NOPRIV - the currently logged in user does not have access to the
  559.            edition file asked for.
  560.         CHANGED - ?
  561.     
  562.     BUGS
  563.         None.
  564.         
  565.  
  566. hotlinks.library/OpenPub                               hotlinks.library/OpenPub
  567.     NAME
  568.         OpenPub - opens a publication file for reading/writing.
  569.             
  570.     SYNOPSIS
  571.         Error = OpenPub(pblock, flags)
  572.          d0               d0     d1
  573.          
  574.         int OpenPub(struct PubBlock *, int);
  575.  
  576.     FUNCTION
  577.         Opens the edition file for read or write. No one else may read/write 
  578.         while the edition file is opened for writing. If opened for write, 
  579.         the version number is incremented and modified date and time are set.
  580.  
  581.     INPUTS
  582.         pblock - must point to a valid PubBlock.
  583.             If pblock->PRec.ID[0] and [1] are 0, this means that a new edition
  584.             file should be created. Call with the following parameters in 
  585.             PubBlock filled in: 
  586.             Type, Access, Name, Desc, Creator.
  587.         flags - 
  588.             OPEN_READ - opens the edition file for reading.
  589.             OPEN_WRITE - opens the edition file for writing.
  590.  
  591.     RESULTS
  592.         NOERROR - the pblock is filled in with the latest information
  593.         NOMEMORY - not enough memory to carry out the open.
  594.         INVPARAM - either the pblock was NULL or had invalid information in it,
  595.            or the flags were incorrect.
  596.         IOERROR - the dos.library Open() called failed.
  597.         INUSE - the edition file is currently in use by another application.
  598.  
  599.     BUGS
  600.         None.
  601.  
  602.  
  603. hotlinks.library/ReadPub                               hotlinks.library/ReadPub
  604.     NAME
  605.         ReadPub - reads data from an edition file into a buffer.
  606.     
  607.     SYNOPSIS
  608.         numbytes = ReadPub(pblock, buffer, len)
  609.           d0               d0      d1     d2
  610.           
  611.         int ReadPub(struct PubBlock *, char *, int);
  612.  
  613.     FUNCTION
  614.         This will read len bytes into buff from the edition file pointed to
  615.         by the pblock.
  616.     
  617.     INPUTS
  618.         pblock - must be a valid pblock previously opened via OpenPub().
  619.         buffer - a pointer to a buffer at least len bytes in size.
  620.         len - the number of bytes to read into buffer.
  621.         
  622.     RESULTS
  623.         numbytes - the actual number of bytes read.
  624.         NOPRIV - the currently logged in user does not have access to the
  625.           specified edition file.
  626.         IOERROR - the dos.library Read() call failed.
  627.        
  628.     SEE ALSO
  629.         OpenPub(), WritePub(), SeekPub(), ClosePub()
  630.  
  631.     BUGS
  632.         None.
  633.  
  634.  
  635. hotlinks.library/WritePub                             hotlinks.library/WritePub
  636.     NAME
  637.         WritePub - writes data to an edition file from a buffer.
  638.     
  639.     SYNOPSIS
  640.         error = WritePub(pblock, buffer, len)
  641.          d0                d0      d1     d2
  642.          
  643.         int WritePub(struct PubBlock *, char *, int);
  644.  
  645.     FUNCTION
  646.         This will read len bytes into buff from the edition specified by 
  647.         pblock.
  648.     
  649.     INPUTS
  650.         pblock - a valid pblock previously opened via OpenPub().
  651.         buffer - a pointer to a buffer at least len bytes long from which
  652.             data will be written to the edition file.
  653.         len - the number of bytes to write to the edition file from buffer.
  654.     
  655.     RESULTS
  656.         NOERROR - no problems occurred while writing. 
  657.         NOPRIV - the currently logged in user does not have access to the
  658.            requested edition file.
  659.         INVPARAM - there was a problem with one of the arguments.
  660.         IOERROR - the dos.library Write() failed or fewer bytes than requested
  661.            were written to the edition.
  662.         CHANGED - ?
  663.  
  664.     SEE ALSO
  665.         OpenPub(), ReadPub(), SeekPub(), ClosePub()
  666.         
  667.     BUGS
  668.         None.
  669.  
  670.  
  671. hotlinks.library/SeekPub                               hotlinks.library/SeekPub
  672.     NAME
  673.         SeekPub - Sets the current read/write position in the file.
  674.     
  675.     SYNOPSIS
  676.         position = SeekPub(pblock, offset, flags)
  677.            d0                d0      d1     d2
  678.            
  679.         int SeekPub(struct PubBlock *, int, int);
  680.  
  681.     FUNCTION
  682.         Sets the current read/write position in the file. Will return the 
  683.         new position in the file relative to the beginning.
  684.  
  685.     INPUTS
  686.         pblock - must be a valid pblock, previously opened by OpenPub().
  687.         offset - the number of bytes to move.
  688.         flags - 
  689.            SEEK_BEGINNING - the offset is from the start of the file.
  690.            SEEK_CURRENT - the offset is from the current position.
  691.            SEEK_END - the offset is from the end of the file.
  692.  
  693.     RESULTS
  694.         position - the new position in the file.
  695.         
  696.         IOERROR - the dos.library Seek() call failed.
  697.         INVPARAM - one of the arguments was invalid.
  698.         NOPRIV - the currently logged in user does not have access to the 
  699.             requested edition file.
  700.  
  701.     SEE ALSO
  702.         OpenPub(), ReadPub(), WritePub(), ClosePub()
  703.     
  704.     BUGS
  705.         None.
  706.  
  707.  
  708. hotlinks.library/ClosePub                             hotlinks.library/ClosePub
  709.     NAME
  710.         ClosePub - closes an edition file.
  711.     
  712.     SYNOPSIS
  713.         error = ClosePub(pblock)
  714.          d0                d0
  715.          
  716.         int ClosePub(struct PubBlock *);
  717.     
  718.     FUNCTION
  719.         This will close the edition file that was opened via OpenPub().
  720.     
  721.     INPUTS
  722.         pblock - must be a valid pblock previously opened via OpenPub().
  723.  
  724.     RESULTS
  725.         NOERROR - the edition file closed without any problems.
  726.         NOPRIV - the currently logged in user does not have access to the
  727.            requested edition file.
  728.         IOERROR - the dos.library Close() call failed.
  729.  
  730.     SEE ALSO
  731.         OpenPub(), ReadPub(), WritePub(), SeekPub()
  732.         
  733.     BUGS
  734.         None.
  735.  
  736.  
  737. hotlinks.library/GetPub                                 hotlinks.library/GetPub
  738.     NAME
  739.         GetPub - presents an edition requester (much like a file requester).
  740.     
  741.     SYNOPSIS
  742.         error = GetPub(pblock, filterproc)
  743.          d0              d0        d1
  744.  
  745.         int GetPub(struct PubBlock *, int (*)());
  746.  
  747.     FUNCTION
  748.         Presents the user with an edition requester. This functions much like
  749.         a file requester except it only shows hotlinks edition files.
  750.         
  751.         The requester will be opened on the screen specified in the 
  752.         HLRegister() call.
  753.         
  754.         Only the editions available to the currently logged in user will be
  755.         shown in the requester.
  756.                 
  757.     INPUTS
  758.         pblock - must be a valid pblock.
  759.         filterproc - a pointer to a procedure that returns an integer in d0.
  760.             The filterproc is called with a pointer to a PubBlock in a0. This
  761.             allows the calling application to display only the editions in the
  762.             edition requester it wants to. It can decide if the edition should
  763.             be displayed by examining the PubBlock (passed in a0) and returning
  764.             ACCEPT or NOACCEPT in d0. This is useful if the application only
  765.             handles one type of edition file (ILBM, DTXT, etc.). If this
  766.             argument is NULL, then all editions will be shown.
  767.  
  768.     RESULTS
  769.         on return - the pblock is filled in with the information for the
  770.            edition the user selected.
  771.            
  772.         NOERROR - the data in the pblock is valid for the selected edition.
  773.  
  774.     SEE ALSO
  775.         PutPub()
  776.         
  777.     BUGS
  778.         None.
  779.  
  780.  
  781. hotlinks.library/PutPub                                 hotlinks.library/PutPub
  782.     NAME
  783.         PutPub - presents a requester for a new edition file.
  784.     
  785.     SYNOPSIS
  786.         Error = PutPub(pblock, filterproc)
  787.          d0              d0        d1
  788.          
  789.         int PutPub(struct PubBlock *, int (*)());
  790.  
  791.     FUNCTION
  792.         This presents the user with a new edition requester and allows
  793.         them to edit the name, description, and access code.
  794.         
  795.         The requester will be opened on the screen specified in the 
  796.         HLRegister() call.
  797.         
  798.         Note that this does not create the edition file, the application must
  799.         still call OpenPub() with the ID set to 0 for the edition to be 
  800.         created.
  801.         
  802.     INPUTS
  803.         pblock - must be a valid pblock returned by AllocPBlock(). The
  804.            pblock->PRec.Name, pblock->PRec.Description, and 
  805.            pblock->PRec.Access will be shown to the user when the requester
  806.            opens. This is used for the application to give some default
  807.            values.
  808.         filterproc - This argument is not utilized at this time and may be
  809.            set to NULL.
  810.  
  811.     RESULTS
  812.         NOERROR - no problem.
  813.         NOMEMORY - not enough memory to open the requester.
  814.         IOERROR - ?
  815.  
  816.     SEE ALSO
  817.         GetPub(), OpenPub()
  818.  
  819.     BUGS
  820.         None.
  821.  
  822.  
  823. hotlinks.library/PubInfo                               hotlinks.library/PubInfo
  824.     NAME
  825.         PubInfo - presents a requester with the information for the edition
  826.                   and allows the user to make changes.
  827.     
  828.     SYNOPSIS
  829.         error = PubInfo(pblock)
  830.          d0               d0
  831.          
  832.         int PubInfo(struct PubBlock *);
  833.  
  834.     FUNCTION
  835.         Presents the user with the new publication requester with the fields
  836.         filled out and allows the user to make changes and save them to the
  837.         edition file.
  838.  
  839.     INPUTS
  840.         pblock - must be a valid pblock.
  841.     
  842.     RESULTS
  843.         NOERROR - the new information is saved to the edition file and changed
  844.            in the pblock.
  845.     
  846.     BUGS
  847.         None.
  848.  
  849.  
  850. hotlinks.library/NewPassword                       hotlinks.library/NewPassword
  851.     NAME
  852.         NewPassword - presents the new password requester.
  853.     
  854.     SYNOPSIS
  855.         error = NewPassword(handle);
  856.          d0                   d0
  857.          
  858.         int NewPassword(ULONG);
  859.  
  860.     FUNCTION
  861.         Presents the user with a requester that allows them to change 
  862.         passwords interactively.
  863.         
  864.         The requester will be opened on the screen specified in the 
  865.         HLRegister() call.        
  866.         
  867.     INPUTS
  868.         handle - must be a valid handle as returned by HLRegister().
  869.         
  870.     RESULTS
  871.         NOERROR - the new password has been successfully saved to the 
  872.             password file.
  873.         
  874.     SEE ALSO
  875.         ChgPassword()
  876.         
  877.     BUGS
  878.         None.
  879.