home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 300-399 / ff368.lzh / ListWindow / listwin_pak.doc < prev    next >
Text File  |  1990-08-15  |  21KB  |  767 lines
  1. TABLE OF CONTENTS
  2.  
  3. listwin_pak/AddListWindowName
  4. listwin_pak/AddName
  5. listwin_pak/AllocateNameList
  6. listwin_pak/AllocateNameListPtrs
  7. listwin_pak/CloseListWindow
  8. listwin_pak/CloseListWindowPackage
  9. listwin_pak/FreeListWindow
  10. listwin_pak/FreeNameList
  11. listwin_pak/FreeNameListPtrs
  12. listwin_pak/HandleListWindow
  13. listwin_pak/InitListWindow
  14. listwin_pak/InitListWindowPackage
  15. listwin_pak/OpenListWindow
  16. listwin_pak/MakeListWindow
  17. listwin_pak/ResizeNameList
  18. listwin_pak/RemoveName
  19. listwin_pak/RemoveListWindowName
  20. listwin_pak/SelectListWindowName
  21. listwin_pak/SetListWindowNameList
  22. listwin_pak/SetNameList
  23. listwin_pak/SetNameListPos
  24. listwin_pak/SortListWindowNames
  25. listwin_pak/SortNameList
  26.  
  27.  
  28. listwin_pak/AddListWindowName                   listwin_pak/AddListWindowName
  29.  
  30.    NAME
  31.       AddListWindowName - add a new name to a List Window name-list
  32.  
  33.    SYNOPSIS
  34.       AddListWindowName(window, name);
  35.  
  36.    PROTOTYPE
  37.       void AddListWindowName(struct Window *, UBYTE *);
  38.  
  39.    FUNCTION
  40.       AddListWindowName calls AddName on the specified ListWindow's NameList
  41.       structure to add the new name to the window's name list, then redraws
  42.       the list.
  43.  
  44.    INPUTS
  45.       window -- pointer to the open List Window
  46.       name   -- UBYTE pointer to the name to add
  47.  
  48.    RETURNS
  49.       None.
  50.  
  51.    BUGS
  52.       None.
  53.  
  54.    SEE ALSO
  55.       AddName(), RemoveListWindowName()
  56.  
  57.  
  58. listwin_pak/AddName                                       listwin_pak/AddName
  59.  
  60.    NAME
  61.       AddName - add a new name to a NameList
  62.  
  63.    SYNOPSIS
  64.       AddName(namelist, name);
  65.  
  66.    PROTOTYPE
  67.       void AddName(struct NameList *, UBYTE *);
  68.  
  69.    FUNCTION
  70.       AddName adds the new pointer to the specified name to the specified
  71.       NameList's name pointer array. If the name array is full, AddName()
  72.       calls ResizeNameList() to add five more available pointer spaces in
  73.       the array, then adds the new name pointer. After the new name is added,
  74.       the NameList is automatically sorted with a call to SortNameList().
  75.  
  76.    INPUTS
  77.       namelist -- pointer to the prepared NameList structure
  78.       name     -- UBYTE pointer to the name to add
  79.  
  80.    RETURNS
  81.       None.
  82.  
  83.    BUGS
  84.       None.
  85.  
  86.    SEE ALSO
  87.       RemoveName(), AddListWindowName()
  88.  
  89.  
  90. listwin_pak/AllocateNameList                     listwin_pak/AllocateNameList
  91.  
  92.    NAME
  93.       AllocateNameList - allocate a NameList structure and name array
  94.  
  95.    SYNOPSIS
  96.       namelist = AllocateNameList(names);
  97.  
  98.    PROTOTYPE
  99.       struct NameList *AllocateNameList(SHORT);
  100.  
  101.    FUNCTION
  102.       AllocateNameList allocates a new NameList structure, and then calls
  103.       AllocateNameListPtrs to allocate the name pointer array for the number
  104.       of names specified.
  105.  
  106.    INPUTS
  107.       names -- number of pointers in the array to allocate
  108.  
  109.    RETURNS
  110.       Pointer to the allocated and initialized NameList structure if
  111.       successful, NULL otherwise.
  112.  
  113.    BUGS
  114.       None.
  115.  
  116.    SEE ALSO
  117.       AllocateNameListPtrs(), FreeNameList()
  118.  
  119.  
  120. listwin_pak/AllocateNameListPtrs             listwin_pak/AllocateNameListPtrs
  121.  
  122.    NAME
  123.       AllocateNameListPtrs - allocates a name pointer array for the NameList
  124.  
  125.    SYNOPSIS
  126.       success = AllocateNameListPtrs(namelist, names);
  127.  
  128.    PROTOTYPE
  129.       int AllocateNameListPtrs(struct NameList *, SHORT);
  130.  
  131.    FUNCTION
  132.       AllocateNameListPtrs allocates a UBYTE array of pointers, to be later
  133.       filled with the addresses of text strings use in the NameList. It
  134.       then attaches this array to the specified NameList.
  135.  
  136.    INPUTS
  137.       namelist -- pointer to an allocated NameList structure
  138.       names    -- number of UBYTE pointers to be allocated in the array
  139.  
  140.    RETURNS
  141.       TRUE if successfull, NULL otherwise.
  142.  
  143.    BUGS
  144.       None.
  145.  
  146.    SEE ALSO
  147.       FreeNameListPtrs()
  148.  
  149.  
  150. listwin_pak/CloseListWindow                       listwin_pak/CloseListWindow
  151.  
  152.    NAME
  153.       CloseListWindow - close and free a ListWindow
  154.  
  155.    SYNOPSIS
  156.       CloseListWindow(window);
  157.  
  158.    PROTOTYPE
  159.       void CloseListWindow(struct Window *);
  160.  
  161.    FUNCTION
  162.       CloseListWindow frees up the memory allocated by MakeListWindow(), by
  163.       calling FreeListWindow(), and then closes the Window. Use this in
  164.       conjunction with OpenListWindow() if no special processing is being
  165.       done to the Window other than the List information.
  166.  
  167.    INPUTS
  168.       window -- pointer to the open List Window to free and close
  169.  
  170.    RETURNS
  171.       None.
  172.  
  173.    BUGS
  174.       None.
  175.  
  176.    SEE ALSO
  177.       OpenListWindow(), FreeListWindow()
  178.  
  179.  
  180. listwin_pak/CloseListWindowPackage         listwin_pak/CloseListWindowPackage
  181.  
  182.    NAME
  183.       CloseListWindowPackage - frees resources allocated with
  184.                                InitListWindowPackage()
  185.  
  186.    SYNOPSIS
  187.       CloseListWindowPackage();
  188.  
  189.    PROTOTYPE
  190.       void CloseListWindowPackage(void);
  191.  
  192.    FUNCTION
  193.       CloseListWindowPackage closes the ConsoleDevice opened with a call to
  194.       InitListWindowPackage(). This is not necessary if key-positioning of
  195.       the list. It is not necessary to call this function if
  196.       InitListWindowPackage() was not called.
  197.  
  198.    INPUTS
  199.       None.
  200.  
  201.    RETURNS
  202.       None.
  203.  
  204.    BUGS
  205.       None.
  206.  
  207.    SEE ALSO
  208.       InitListWindowPackage()
  209.  
  210.  
  211. listwin_pak/FreeListWindow                         listwin_pak/FreeListWindow
  212.  
  213.    NAME
  214.       FreeListWindow - free the memory allocated with MakeListWindow()
  215.  
  216.    SYNOPSIS
  217.       FreeListWindow(window);
  218.  
  219.    PROTOTYPE
  220.       void FreeListWindow(struct Window *);
  221.  
  222.    FUNCTION
  223.       FreeListWindow frees up the memory allocated with MakeListWindow(),
  224.       including the removal of the scroll gadgets and freeing of the NameList
  225.       if a pointer to it still remains. If your application sets up and
  226.       maintains its own NameList structures, be sure to call
  227.       SetListWindowNameList() with a NULL pointer for the NameList, before
  228.       calling this function, so FreeListWindow() will not attempt to
  229.       deallocate that memory. If you use InitListWindow() to set up the
  230.       NameList, then it is safe to simply call this function to clear up
  231.       all allocated memory for that List Window.
  232.       Use this function in conjunction with MakeListWindow() if you are
  233.       doing something special to the windows in addition to the list.
  234.       This function does not close the window.
  235.  
  236.    INPUTS
  237.       window -- pointer to the Window that contains the List Window to free
  238.  
  239.    RETURNS
  240.       None.
  241.  
  242.    BUGS
  243.       None.
  244.  
  245.    SEE ALSO
  246.       MakeListWindow()
  247.  
  248.  
  249. listwin_pak/FreeNameList                             listwin_pak/FreeNameList
  250.  
  251.    NAME
  252.       FreeNameList - free a NameList and its name pointer array
  253.  
  254.    SYNOPSIS
  255.       FreeNameList(namelist);
  256.  
  257.    PROTOTYPE
  258.       void FreeNameList(struct NameList *);
  259.  
  260.    FUNCTION
  261.       FreeNameList calls FreeNameListPtrs() to deallocate the specified
  262.       NameList's pointer array, then frees the NameList structure.
  263.  
  264.    INPUTS
  265.       namelist -- pointer to the NameList to deallocate
  266.  
  267.    RETURNS
  268.       None.
  269.  
  270.    BUGS
  271.       None.
  272.  
  273.    SEE ALSO
  274.       AllocateNameList(), FreeNameListPtrs()
  275.  
  276.  
  277. listwin_pak/FreeNameListPtrs                     listwin_pak/FreeNameListPtrs
  278.  
  279.    NAME
  280.       FreeNameListPtrs - free a NameList's name pointer array
  281.  
  282.    SYNOPSIS
  283.       FreeNameListPtrs(namelist);
  284.  
  285.    PROTOTYPE
  286.       void FreeNameListPtrs(struct NameList *);
  287.  
  288.    FUNCTION
  289.       FreeNameListPtrs frees the name pointer array of the specified NameList
  290.       structure.
  291.  
  292.    INPUTS
  293.       namelist -- pointer to the NameList to free the name array of
  294.  
  295.    RETURNS
  296.       None.
  297.  
  298.    BUGS
  299.       None.
  300.  
  301.    SEE ALSO
  302.       AllocateNameListPtrs(), FreeNameList()
  303.  
  304.  
  305. listwin_pak/HandleListWindow                     listwin_pak/HandleListWindow
  306.  
  307.    NAME
  308.       HandleListWindow - handle user operations on a List Window
  309.  
  310.    SYNOPSIS
  311.       code = HandleListWindow(message, buffer);
  312.  
  313.    PROTOTYPE
  314.       int HandleListWindow(struct IntuiMessage *, UBYTE *);
  315.  
  316.    FUNCTION
  317.       HandleListWindow controls resizing/drawing of the ListWindow, and
  318.       handles various messages directed toward the window, such as scrolling
  319.       gadgets, arrow-keys, and name selection. Once your application program
  320.       realizes the message is directed toward a List Window, pass an entire
  321.       copy of the message to this function, along with a pointer to a text
  322.       buffer to hold the name if selected. Be sure to make your copy of the
  323.       message before ReplyMsg/ing to it.
  324.  
  325.    INPUTS
  326.       message -- pointer to a copy of the IntuiMessage structure received
  327.                  from the host application
  328.       buffer  -- pointer to a UBYTE buffer large enough to hold the name
  329.                  of the largest string in the list
  330.  
  331.    RETURNS
  332.       CLOSE_LISTWINDOW -- if the window has a CLOSEWINDOW gadget, and this
  333.                           was selected, this integer code is returned
  334.       GOT_NAME         -- if a name was selected, or the list was scrolled
  335.                           with a selected "slot", this code is returned. Look
  336.                           in the buffer to find the name that was under the
  337.                           selected "slot".
  338.       LISTWINDOW_NONE  -- nothing your program needs to know about happened
  339.                           to the window (well, you MIGHT need to know, but
  340.                           this package is meant to be transparent). You get
  341.                           this if CLOSEWINDOW WASN'T selected or there are
  342.                           no selected names (this includes scrolling,
  343.                           dragging, and resizing).
  344.  
  345.    BUGS
  346.       None.
  347.  
  348.    SEE ALSO
  349.  
  350.  
  351. listwin_pak/InitListWindow                         listwin_pak/InitListWindow
  352.  
  353.    NAME
  354.       InitListWindow - set up a List Window's name list
  355.  
  356.    SYNOPSIS
  357.       success = InitListWindow(window, name_array, names, position);
  358.  
  359.    PROTOTYPE
  360.       int InitListWindow(struct Window *, UBYTE **, SHORT, SHORT);
  361.  
  362.    FUNCTION
  363.       InitListWindow creates a NameList and copies the specified name-list
  364.       array into it, then draws the window starting the list at the specified
  365.       position. This is used if you are passing a pre-created array of text
  366.       string pointers, with the specified number of pointers in the array.
  367.  
  368.    INPUTS
  369.       window -- pointer to the window containing the ListWindow to initialize
  370.       name_array -- pointer to an array of UBYTE pointers to text strings
  371.       names      -- number of text string pointers in the array
  372.       position   -- position to draw the list at (0 = top of list)
  373.  
  374.    RETURNS
  375.       TRUE if the ListWindow exists and the NameList was allocated
  376.       successfully, NULL of otherwise.
  377.  
  378.    BUGS
  379.       None.
  380.  
  381.    SEE ALSO
  382.       SetListWindowNameList()
  383.  
  384.  
  385. listwin_pak/InitListWindowPackage           listwin_pak/InitListWindowPackage
  386.  
  387.    NAME
  388.       InitListWindowPackage - initialize ListWindow Package module-locals
  389.  
  390.    SYNOPSIS
  391.       success = InitListWindowPackage();
  392.  
  393.    PROTOTYPE
  394.       int InitListWindowPackage(void);
  395.  
  396.    FUNCTION
  397.       InitListWindowPackage opens the Console Device and initializes proper
  398.       translation of RAWKEY codes into the default KEYMAP character codes.
  399.       InitListWindowPackage is necessary only if you require key searching
  400.       of your lists. This is accomplished by holding SHIFT and a key when
  401.       the desired list window is active. The list window will display the
  402.       first name in the list that has the key pressed as its first letter,
  403.       or the next closest name if none has that letter. Normal ARROW-KEY
  404.       scrolling of the list will work without a call to this function.
  405.  
  406.    INPUTS
  407.       None.
  408.  
  409.    RETURNS
  410.       TRUE if the ConsoleDevice is successfully opened, NULL otherwise.
  411.  
  412.    BUGS
  413.       None.
  414.  
  415.    SEE ALSO
  416.       CloseListWindowPackage()
  417.  
  418.  
  419. listwin_pak/OpenListWindow                         listwin_pak/OpenListWindow
  420.  
  421.    NAME
  422.       OpenListWindow - open a window and initialize it as a List Window
  423.  
  424.    SYNOPSIS
  425.       window = OpenListWindow(new_window);
  426.  
  427.    PROTOTYPE
  428.       struct Window *OpenListWindow(struct NewWindow *);
  429.  
  430.    FUNCTION
  431.       OpenListWindow opens a standard window and calls MakeListWindow() to
  432.       initialize it as a List Window.
  433.  
  434.    INPUTS
  435.       new_window -- pointer to a NewWindow structure (see Intuition Manual)
  436.  
  437.       The List Window will behave depending on what flags you have set within
  438.       the NewWindow structure (CLOSEWINDOW, WINDOWDRAG, WINDOWSIZING, etc.).
  439.  
  440.    RETURNS
  441.       If successful, returns a pointer to the newly opened Window, otherwise
  442.       NULL.
  443.  
  444.    BUGS
  445.       None.
  446.  
  447.    SEE ALSO
  448.       CloseListWindow(), MakeListWindow()
  449.       InitListWindow(), HandleListWindow()
  450.  
  451.  
  452. listwin_pak/MakeListWindow                         listwin_pak/MakeListWindow
  453.  
  454.    NAME
  455.       MakeListWindow - makes the specified window into a List Window
  456.  
  457.    SYNOPSIS
  458.       success = MakeListWindow(window);
  459.  
  460.    PROTOTYPE
  461.       int MakeListWindow(struct Window *);
  462.  
  463.    FUNCTION
  464.       MakeListWindow takes the specified window and allocates the necessary
  465.       List Window structures to make it into a List Window, including the
  466.       scroller gadgets and internal state information for that window. It
  467.       attaches this information to the UserData pointer of the Window
  468.       structure, so be sure not to use this pointer for other application
  469.       use, as other ListWindow functions use this data space.
  470.  
  471.    INPUTS
  472.       window -- pointer to an opened Window to be made into a List Window
  473.  
  474.    RETURNS
  475.       TRUE if all memory is allocated successfully, NULL if not.
  476.  
  477.    BUGS
  478.       None.
  479.  
  480.    SEE ALSO
  481.       FreeListWindow(), InitListWindow()
  482.  
  483.  
  484. listwin_pak/ResizeNameList                         listwin_pak/ResizeNameList
  485.  
  486.    NAME
  487.       ResizeNameList - change the size of a NameList name pointer array
  488.  
  489.    SYNOPSIS
  490.       success = ResizeNameList(namelist, names);
  491.  
  492.    PROTOTYPE
  493.       int ResizeNameList(struct NameList *, ULONG);
  494.  
  495.    FUNCTION
  496.       ResizeNameList changes the size of a NameList name pointer array.
  497.       A new pointer array is allocated, and the pointers from the original
  498.       are copied (up until the length of the new array, if it is smaller)
  499.       into the new array. If the sizes are the same, nothing happens.
  500.  
  501.    INPUTS
  502.       namelist -- pointer to the NameList structure to affect
  503.       names    -- number of names in the new list
  504.  
  505.    RETURNS
  506.       TRUE if the new array is successfully allocated, NULL otherwise.
  507.  
  508.    BUGS
  509.       None.
  510.  
  511.    SEE ALSO
  512.       AddName(), RemoveName()
  513.  
  514.  
  515. listwin_pak/RemoveName                                 listwin_pak/RemoveName
  516.  
  517.    NAME
  518.       RemoveName - removes a name from a NameList
  519.  
  520.    SYNOPSIS
  521.       RemoveName(namelist, name);
  522.  
  523.    PROTOTYPE
  524.       void RemoveName(struct NameList *, UBYTE *);
  525.  
  526.    FUNCTION
  527.       RemoveName searches the specified NameList name pointer array for the
  528.       specified name, and, if found, removes the name pointer from the list.
  529.       After the name is removed, the list is resorted with a call to
  530.       SortNameList().
  531.  
  532.    INPUTS
  533.       namelist -- pointer to the NameList structure to affect
  534.       name     -- UBYTE pointer to the name to remove
  535.  
  536.    RETURNS
  537.       None.
  538.  
  539.    BUGS
  540.       None.
  541.  
  542.    SEE ALSO
  543.       RemoveListWindowName(), AddName()
  544.  
  545.  
  546. listwin_pak/RemoveListWindowName             listwin_pak/RemoveListWindowName
  547.  
  548.    NAME
  549.       RemoveListWindowName - remove a name from a List Window list
  550.  
  551.    SYNOPSIS
  552.       RemoveListWindowName(window, name);
  553.  
  554.    PROTOTYPE
  555.       void RemoveListWindowName(struct Window *, UBYTE *);
  556.  
  557.    FUNCTION
  558.       RemoveListWindowName calls RemoveName on the specified ListWindow's
  559.       NameList structure to remove the specified name from the list. Then
  560.       it redraws the list.
  561.  
  562.    INPUTS
  563.       window -- pointer to the List Window to affect
  564.       name   -- UBYTE pointer to the name to remove from the list
  565.  
  566.    RETURNS
  567.       None.
  568.  
  569.    BUGS
  570.       None.
  571.  
  572.    SEE ALSO
  573.       RemoveName(), AddListWindowName()
  574.  
  575.  
  576. listwin_pak/SelectListWindowName             listwin_pak/SelectListWindowName
  577.  
  578.    NAME
  579.       SelectListWindowName - select and highlight a List Window name
  580.  
  581.    SYNOPSIS
  582.       SelectListWindowName(window, name);
  583.  
  584.    PROTOTYPE
  585.       void SelectListWindowName(struct Window *, UBYTE *);
  586.  
  587.    FUNCTION
  588.       SelectListWindowName searches the specified List Window for the
  589.       specified name, and, if found, redraws the list with a view of the
  590.       name and then selects and hilights it.
  591.  
  592.    INPUTS
  593.       window -- pointer to the List Window to affect
  594.       name   -- UBYTE pointer to the name to select
  595.  
  596.    RETURNS
  597.       None.
  598.  
  599.    BUGS
  600.       None.
  601.  
  602.    SEE ALSO
  603.  
  604.  
  605. listwin_pak/SetListWindowNameList           listwin_pak/SetListWindowNameList
  606.  
  607.    NAME
  608.       SetListWindowNameList - assign a NameList to a ListWindow
  609.  
  610.    SYNOPSIS
  611.       SetListWindowNameList(window, namelist, position);
  612.  
  613.    PROTOTYPE
  614.       void SetListWindowNameList(struct Window *, struct NameList *, SHORT);
  615.  
  616.    FUNCTION
  617.       SetListWindowNameList assigns the specified NameList to the specified
  618.       ListWindow, and then redraws the list starting at the specified
  619.       position. This is useful if you maintain your own NameLists within your
  620.       application, and simply need to assign the proper ones to your List
  621.       Window. If your application has allocated its own NameLists, be sure
  622.       to pass a NULL pointer for the namelist to this function, before
  623.       calling CloseListWindow() or FreeListWindow(), unless you want the
  624.       package to deallocate your NameList for you.
  625.       This function calls SetNameListPos() to redraw the list.
  626.  
  627.    INPUTS
  628.       window   -- pointer to the open Window to set the new NameList for
  629.       namelist -- pointer to the NameList to assign to the List Window
  630.       position -- position to draw the list at (0 == start of list)
  631.  
  632.    RETURNS
  633.       None.
  634.  
  635.    BUGS
  636.       None.
  637.  
  638.    SEE ALSO
  639.       SetNameListPos()
  640.  
  641.  
  642. listwin_pak/SetNameList                               listwin_pak/SetNameList
  643.  
  644.    NAME
  645.       SetNameList - copy a prepared array of UBYTE pointers into a NameList
  646.  
  647.    SYNOPSIS
  648.       SetNameList(namelist, name_array, names);
  649.  
  650.    PROTOTYPE
  651.       void SetNameList(struct NameList *, UBYTE **, ULONG);
  652.  
  653.    FUNCTION
  654.       SetNameList copies the pointers provided in a UBYTE pointer array
  655.       into the array of a prepared NameList structure, up to the specified
  656.       number of names, or the available number of name pointers within the
  657.       NameList, whichever is least. Make sure the NameList has an allocated
  658.       pointer array before using this function. SetNameList does not adjust
  659.       the size of the destination NameList to fit the number of name pointers
  660.       provided.
  661.  
  662.    INPUTS
  663.       namelist   -- pointer to the prepared NameList structure to copy the
  664.                     name pointers into
  665.       name_array -- a pointer to an array of UBYTE text pointers which point
  666.                     to NULL-terminated strings
  667.       names      -- number of name pointers in array
  668.  
  669.    RETURNS
  670.       None.
  671.  
  672.    BUGS
  673.       None.
  674.  
  675.    SEE ALSO
  676.       ResizeNameList(), AddName(), RemoveName()
  677.  
  678.  
  679. listwin_pak/SetNameListPos                         listwin_pak/SetNameListPos
  680.  
  681.    NAME
  682.       SetNameListPos - redraw the list at the specified position
  683.  
  684.    SYNOPSIS
  685.       SetNameListPos(window, position);
  686.  
  687.    PROTOTYPE
  688.       void SetNameListPos(struct Window *, SHORT);
  689.  
  690.    FUNCTION
  691.       SetNameListPos redraws the specified ListWindow starting at the
  692.       specified position (0 == start of list). Use a very high number to
  693.       set it at the last page if information, is this is necessary. If there
  694.       is no NameList for the specified List Window, this will clear the
  695.       entries from the window.
  696.  
  697.    INPUTS
  698.       window   -- pointer to the opened Window to redraw the NameList for
  699.       position -- position to start the list at
  700.  
  701.    RETURNS
  702.       None.
  703.  
  704.    BUGS
  705.       None.
  706.  
  707.    SEE ALSO
  708.       SetListWindowNameList()
  709.  
  710.  
  711. listwin_pak/SortListWindowNames               listwin_pak/SortListWindowNames
  712.  
  713.    NAME
  714.       SortListWindowNames - sort the list in a ListWindow
  715.  
  716.    SYNOPSIS
  717.       SortListWindowNames(window);
  718.  
  719.    PROTOTYPE
  720.       void SortListWindowNames(struct Window *);
  721.  
  722.    FUNCTION
  723.       SortListWindowNames calls SortNameList() on the NameList structure
  724.       within the ListWindow data.
  725.  
  726.    INPUTS
  727.       window -- pointer to the open List Window
  728.  
  729.    RETURNS
  730.       None.
  731.  
  732.    BUGS
  733.       None (see SortNameList()).
  734.  
  735.    SEE ALSO
  736.       SortNameList()
  737.  
  738.  
  739. listwin_pak/SortNameList                             listwin_pak/SortNameList
  740.  
  741.    NAME
  742.       SortNameList - sort the names within a prepared NameList structure
  743.  
  744.    SYNOPSIS
  745.       SortNameList(namelist);
  746.  
  747.    PROTOTYPE
  748.       void SortNameList(struct NameList *);
  749.  
  750.    FUNCTION
  751.       SortNameList calls the internal Lattice sorting algorithm tqsort()
  752.       on the array of text pointers within the specified NameList structure,
  753.       to arrange the pointers so that their associated strings are in
  754.       alphabetic order.
  755.  
  756.    INPUTS
  757.       namelist -- pointer to the prepared NameList structure to sort
  758.  
  759.    RETURNS
  760.       None.
  761.  
  762.    BUGS
  763.       None (unless your standard library doesn't have tqsort()).
  764.  
  765.    SEE ALSO
  766.       SortListWindowNames()
  767.