开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
ftlist.h
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：16k
源码类别：

其他游戏

开发平台：

Visual C++

ftlist.h：源码内容
  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*  ftlist.h                                                               */
  4. /*                                                                         */
  5. /*    Generic list support for FreeType (specification).                   */
  6. /*                                                                         */
  7. /*  Copyright 1996-2001, 2003, 2007 by                                     */
  8. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  9. /*                                                                         */
  10. /*  This file is part of the FreeType project, and may only be used,       */
  11. /*  modified, and distributed under the terms of the FreeType project      */
  12. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13. /*  this file you indicate that you have read the license and              */
  14. /*  understand and accept it fully.                                        */
  15. /*                                                                         */
  16. /***************************************************************************/
  19.   /*************************************************************************/
  20.   /*                                                                       */
  21.   /*  This file implements functions relative to list processing.  Its     */
  22.   /*  data structures are defined in `freetype.h'.                         */
  23.   /*                                                                       */
  24.   /*************************************************************************/
  27. #ifndef __FTLIST_H__
  28. #define __FTLIST_H__
  31. #include <ft2build.h>
  32. #include FT_FREETYPE_H
  34. #ifdef FREETYPE_H
  35. #error "freetype.h of FreeType 1 has been loaded!"
  36. #error "Please fix the directory search order for header files"
  37. #error "so that freetype.h of FreeType 2 is found first."
  38. #endif
  41. FT_BEGIN_HEADER
  44.   /*************************************************************************/
  45.   /*                                                                       */
  46.   /* <Section>                                                             */
  47.   /*    list_processing                                                    */
  48.   /*                                                                       */
  49.   /* <Title>                                                               */
  50.   /*    List Processing                                                    */
  51.   /*                                                                       */
  52.   /* <Abstract>                                                            */
  53.   /*    Simple management of lists.                                        */
  54.   /*                                                                       */
  55.   /* <Description>                                                         */
  56.   /*    This section contains various definitions related to list          */
  57.   /*    processing using doubly-linked nodes.                              */
  58.   /*                                                                       */
  59.   /* <Order>                                                               */
  60.   /*    FT_List                                                            */
  61.   /*    FT_ListNode                                                        */
  62.   /*    FT_ListRec                                                         */
  63.   /*    FT_ListNodeRec                                                     */
  64.   /*                                                                       */
  65.   /*    FT_List_Add                                                        */
  66.   /*    FT_List_Insert                                                     */
  67.   /*    FT_List_Find                                                       */
  68.   /*    FT_List_Remove                                                     */
  69.   /*    FT_List_Up                                                         */
  70.   /*    FT_List_Iterate                                                    */
  71.   /*    FT_List_Iterator                                                   */
  72.   /*    FT_List_Finalize                                                   */
  73.   /*    FT_List_Destructor                                                 */
  74.   /*                                                                       */
  75.   /*************************************************************************/
  78.   /*************************************************************************/
  79.   /*                                                                       */
  80.   /* <Function>                                                            */
  81.   /*    FT_List_Find                                                       */
  82.   /*                                                                       */
  83.   /* <Description>                                                         */
  84.   /*    Finds the list node for a given listed object.                     */
  85.   /*                                                                       */
  86.   /* <Input>                                                               */
  87.   /*    list :: A pointer to the parent list.                              */
  88.   /*    data :: The address of the listed object.                          */
  89.   /*                                                                       */
  90.   /* <Return>                                                              */
  91.   /*    List node.  NULL if it wasn't found.                               */
  92.   /*                                                                       */
  93.   FT_EXPORT( FT_ListNode )
  94.   FT_List_Find( FT_List  list,
  95.                 void*    data );
  98.   /*************************************************************************/
  99.   /*                                                                       */
  100.   /* <Function>                                                            */
  101.   /*    FT_List_Add                                                        */
  102.   /*                                                                       */
  103.   /* <Description>                                                         */
  104.   /*    Appends an element to the end of a list.                           */
  105.   /*                                                                       */
  106.   /* <InOut>                                                               */
  107.   /*    list :: A pointer to the parent list.                              */
  108.   /*    node :: The node to append.                                        */
  109.   /*                                                                       */
  110.   FT_EXPORT( void )
  111.   FT_List_Add( FT_List      list,
  112.                FT_ListNode  node );
  115.   /*************************************************************************/
  116.   /*                                                                       */
  117.   /* <Function>                                                            */
  118.   /*    FT_List_Insert                                                     */
  119.   /*                                                                       */
  120.   /* <Description>                                                         */
  121.   /*    Inserts an element at the head of a list.                          */
  122.   /*                                                                       */
  123.   /* <InOut>                                                               */
  124.   /*    list :: A pointer to parent list.                                  */
  125.   /*    node :: The node to insert.                                        */
  126.   /*                                                                       */
  127.   FT_EXPORT( void )
  128.   FT_List_Insert( FT_List      list,
  129.                   FT_ListNode  node );
  132.   /*************************************************************************/
  133.   /*                                                                       */
  134.   /* <Function>                                                            */
  135.   /*    FT_List_Remove                                                     */
  136.   /*                                                                       */
  137.   /* <Description>                                                         */
  138.   /*    Removes a node from a list.  This function doesn't check whether   */
  139.   /*    the node is in the list!                                           */
  140.   /*                                                                       */
  141.   /* <Input>                                                               */
  142.   /*    node :: The node to remove.                                        */
  143.   /*                                                                       */
  144.   /* <InOut>                                                               */
  145.   /*    list :: A pointer to the parent list.                              */
  146.   /*                                                                       */
  147.   FT_EXPORT( void )
  148.   FT_List_Remove( FT_List      list,
  149.                   FT_ListNode  node );
  152.   /*************************************************************************/
  153.   /*                                                                       */
  154.   /* <Function>                                                            */
  155.   /*    FT_List_Up                                                         */
  156.   /*                                                                       */
  157.   /* <Description>                                                         */
  158.   /*    Moves a node to the head/top of a list.  Used to maintain LRU      */
  159.   /*    lists.                                                             */
  160.   /*                                                                       */
  161.   /* <InOut>                                                               */
  162.   /*    list :: A pointer to the parent list.                              */
  163.   /*    node :: The node to move.                                          */
  164.   /*                                                                       */
  165.   FT_EXPORT( void )
  166.   FT_List_Up( FT_List      list,
  167.               FT_ListNode  node );
  170.   /*************************************************************************/
  171.   /*                                                                       */
  172.   /* <FuncType>                                                            */
  173.   /*    FT_List_Iterator                                                   */
  174.   /*                                                                       */
  175.   /* <Description>                                                         */
  176.   /*    An FT_List iterator function which is called during a list parse   */
  177.   /*    by @FT_List_Iterate.                                               */
  178.   /*                                                                       */
  179.   /* <Input>                                                               */
  180.   /*    node :: The current iteration list node.                           */
  181.   /*                                                                       */
  182.   /*    user :: A typeless pointer passed to @FT_List_Iterate.             */
  183.   /*            Can be used to point to the iteration's state.             */
  184.   /*                                                                       */
  185.   typedef FT_Error
  186.   (*FT_List_Iterator)( FT_ListNode  node,
  187.                        void*        user );
  190.   /*************************************************************************/
  191.   /*                                                                       */
  192.   /* <Function>                                                            */
  193.   /*    FT_List_Iterate                                                    */
  194.   /*                                                                       */
  195.   /* <Description>                                                         */
  196.   /*    Parses a list and calls a given iterator function on each element. */
  197.   /*    Note that parsing is stopped as soon as one of the iterator calls  */
  198.   /*    returns a non-zero value.                                          */
  199.   /*                                                                       */
  200.   /* <Input>                                                               */
  201.   /*    list     :: A handle to the list.                                  */
  202.   /*    iterator :: An iterator function, called on each node of the list. */
  203.   /*    user     :: A user-supplied field which is passed as the second    */
  204.   /*                argument to the iterator.                              */
  205.   /*                                                                       */
  206.   /* <Return>                                                              */
  207.   /*    The result (a FreeType error code) of the last iterator call.      */
  208.   /*                                                                       */
  209.   FT_EXPORT( FT_Error )
  210.   FT_List_Iterate( FT_List           list,
  211.                    FT_List_Iterator  iterator,
  212.                    void*             user );
  215.   /*************************************************************************/
  216.   /*                                                                       */
  217.   /* <FuncType>                                                            */
  218.   /*    FT_List_Destructor                                                 */
  219.   /*                                                                       */
  220.   /* <Description>                                                         */
  221.   /*    An @FT_List iterator function which is called during a list        */
  222.   /*    finalization by @FT_List_Finalize to destroy all elements in a     */
  223.   /*    given list.                                                        */
  224.   /*                                                                       */
  225.   /* <Input>                                                               */
  226.   /*    system :: The current system object.                               */
  227.   /*                                                                       */
  228.   /*    data   :: The current object to destroy.                           */
  229.   /*                                                                       */
  230.   /*    user   :: A typeless pointer passed to @FT_List_Iterate.  It can   */
  231.   /*              be used to point to the iteration's state.               */
  232.   /*                                                                       */
  233.   typedef void
  234.   (*FT_List_Destructor)( FT_Memory  memory,
  235.                          void*      data,
  236.                          void*      user );
  239.   /*************************************************************************/
  240.   /*                                                                       */
  241.   /* <Function>                                                            */
  242.   /*    FT_List_Finalize                                                   */
  243.   /*                                                                       */
  244.   /* <Description>                                                         */
  245.   /*    Destroys all elements in the list as well as the list itself.      */
  246.   /*                                                                       */
  247.   /* <Input>                                                               */
  248.   /*    list    :: A handle to the list.                                   */
  249.   /*                                                                       */
  250.   /*    destroy :: A list destructor that will be applied to each element  */
  251.   /*               of the list.                                            */
  252.   /*                                                                       */
  253.   /*    memory  :: The current memory object which handles deallocation.   */
  254.   /*                                                                       */
  255.   /*    user    :: A user-supplied field which is passed as the last       */
  256.   /*               argument to the destructor.                             */
  257.   /*                                                                       */
  258.   FT_EXPORT( void )
  259.   FT_List_Finalize( FT_List             list,
  260.                     FT_List_Destructor  destroy,
  261.                     FT_Memory           memory,
  262.                     void*               user );
  265.   /* */
  268. FT_END_HEADER
  270. #endif /* __FTLIST_H__ */
  273. /* END */