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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
NameRegistry.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：20k
源码类别：

多媒体编程

开发平台：

Visual C++

NameRegistry.h：源码内容
  1. /*
  2.      File:       NameRegistry.h
  3.  
  4.      Contains:   NameRegistry Interfaces
  5.  
  6.      Version:    Technology: MacOS
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1993-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __NAMEREGISTRY__
  18. #define __NAMEREGISTRY__
  20. #ifndef __MACTYPES__
  21. #include "MacTypes.h"
  22. #endif
  27. #if PRAGMA_ONCE
  28. #pragma once
  29. #endif
  31. #ifdef __cplusplus
  32. extern "C" {
  33. #endif
  35. #if PRAGMA_IMPORT
  36. #pragma import on
  37. #endif
  39. #if PRAGMA_STRUCT_ALIGN
  40.     #pragma options align=power
  41. #elif PRAGMA_STRUCT_PACKPUSH
  42.     #pragma pack(push, 2)
  43. #elif PRAGMA_STRUCT_PACK
  44.     #pragma pack(2)
  45. #endif
  47. /*******************************************************************************
  48.  * 
  49.  * Foundation Types
  50.  *
  51.  */
  52. /* Value of a property */
  53. typedef void *                          RegPropertyValue;
  54. /* Length of property value */
  55. typedef UInt32                          RegPropertyValueSize;
  56. /*******************************************************************************
  57.  * 
  58.  * RegEntryID   :   The Global x-Namespace Entry Identifier
  59.  *
  60.  */
  62. struct RegEntryID {
  63.     UInt32                          contents[4];
  64. };
  65. typedef struct RegEntryID               RegEntryID;
  66. typedef RegEntryID *                    RegEntryIDPtr;
  67. /*******************************************************************************
  68.  *
  69.  * Root Entry Name Definitions  (Applies to all Names in the RootNameSpace)
  70.  *
  71.  *  o Names are a colon-separated list of name components.  Name components
  72.  *    may not themselves contain colons.  
  73.  *  o Names are presented as null-terminated ASCII character strings.
  74.  *  o Names follow similar parsing rules to Apple file system absolute
  75.  *    and relative paths.  However the '::' parent directory syntax is
  76.  *    not currently supported.
  77.  */
  78. /* Max length of Entry Name */
  79. enum {
  80.     kRegCStrMaxEntryNameLength  = 47
  81. };
  83. /* Entry Names are single byte ASCII */
  85. typedef char                            RegCStrEntryName;
  86. typedef char *                          RegCStrEntryNamePtr;
  87. /* length of RegCStrEntryNameBuf =  kRegCStrMaxEntryNameLength+1*/
  88. typedef char                            RegCStrEntryNameBuf[48];
  89. typedef char                            RegCStrPathName;
  90. typedef UInt32                          RegPathNameSize;
  91. enum {
  92.     kRegPathNameSeparator       = ':',                          /* 0x3A */
  93.     kRegEntryNameTerminator     = 0x00,                         /* '' */
  94.     kRegPathNameTerminator      = 0x00                          /* '' */
  95. };
  97. /*******************************************************************************
  98.  *
  99.  * Property Name and ID Definitions
  100.  *  (Applies to all Properties Regardless of NameSpace)
  101.  */
  102. enum {
  103.     kRegMaximumPropertyNameLength = 31,                         /* Max length of Property Name */
  104.     kRegPropertyNameTerminator  = 0x00                          /* '' */
  105. };
  107. typedef char                            RegPropertyNameBuf[32];
  108. typedef char                            RegPropertyName;
  109. typedef char *                          RegPropertyNamePtr;
  110. /*******************************************************************************
  111.  *
  112.  * Iteration Operations
  113.  *
  114.  *  These specify direction when traversing the name relationships
  115.  */
  116. typedef UInt32                          RegIterationOp;
  117. typedef RegIterationOp                  RegEntryIterationOp;
  118. enum {
  119.                                                                 /* Absolute locations*/
  120.     kRegIterRoot                = 0x00000002,                   /* "Upward" Relationships */
  121.     kRegIterParents             = 0x00000003,                   /* include all  parent(s) of entry */
  122.                                                                 /* "Downward" Relationships*/
  123.     kRegIterChildren            = 0x00000004,                   /* include all children */
  124.     kRegIterSubTrees            = 0x00000005,                   /* include all sub trees of entry */
  125.     kRegIterDescendants         = 0x00000005,                   /* include all descendants of entry */
  126.                                                                 /* "Horizontal" Relationships */
  127.     kRegIterSibling             = 0x00000006,                   /* include all siblings */
  128.                                                                 /* Keep doing the same thing*/
  129.     kRegIterContinue            = 0x00000001
  130. };
  132. /*******************************************************************************
  133.  *
  134.  * Name Entry and Property Modifiers
  135.  *
  136.  *
  137.  *
  138.  * Modifiers describe special characteristics of names
  139.  * and properties.  Modifiers might be supported for
  140.  * some names and not others.
  141.  * 
  142.  * Device Drivers should not rely on functionality
  143.  * specified as a modifier.
  144.  */
  145. typedef UInt32                          RegModifiers;
  146. typedef RegModifiers                    RegEntryModifiers;
  147. typedef RegModifiers                    RegPropertyModifiers;
  148. enum {
  149.     kRegNoModifiers             = 0x00000000,                   /* no entry modifiers in place */
  150.     kRegUniversalModifierMask   = 0x0000FFFF,                   /* mods to all entries */
  151.     kRegNameSpaceModifierMask   = 0x00FF0000,                   /* mods to all entries within namespace */
  152.     kRegModifierMask            = (long)0xFF000000              /* mods to just this entry */
  153. };
  155. /* Universal Property Modifiers */
  156. enum {
  157.     kRegPropertyValueIsSavedToNVRAM = 0x00000020,               /* property is non-volatile (saved in NVRAM) */
  158.     kRegPropertyValueIsSavedToDisk = 0x00000040                 /* property is non-volatile (saved on disk) */
  159. };
  161. /* NameRegistry version, Gestalt/PEF-style -- MUST BE KEPT IN SYNC WITH MAKEFILE !! */
  162. enum {
  163.     LatestNR_PEFVersion         = 0x01030000                    /* latest NameRegistryLib version (Gestalt/PEF-style) */
  164. };
  166. /* ///////////////////////
  167. //
  168. // The Registry API
  169. //
  170. /////////////////////// */
  171. /* NameRegistry dispatch indexes */
  172. enum {
  173.     kSelectRegistryEntryIDInit  = 0,
  174.     kSelectRegistryEntryIDCompare = 1,
  175.     kSelectRegistryEntryIDCopy  = 2,
  176.     kSelectRegistryEntryIDDispose = 3,
  177.     kSelectRegistryCStrEntryCreate = 4,
  178.     kSelectRegistryEntryDelete  = 5,
  179.     kSelectRegistryEntryCopy    = 6,
  180.     kSelectRegistryEntryIterateCreate = 7,
  181.     kSelectRegistryEntryIterateDispose = 8,
  182.     kSelectRegistryEntryIterateSet = 9,
  183.     kSelectRegistryEntryIterate = 10,
  184.     kSelectRegistryEntrySearch  = 11,
  185.     kSelectRegistryCStrEntryLookup = 12,
  186.     kSelectRegistryEntryToPathSize = 13,
  187.     kSelectRegistryCStrEntryToPath = 14,
  188.     kSelectRegistryCStrEntryToName = 15,
  189.     kSelectRegistryPropertyCreate = 16,
  190.     kSelectRegistryPropertyDelete = 17,
  191.     kSelectRegistryPropertyRename = 18,
  192.     kSelectRegistryPropertyIterateCreate = 19,
  193.     kSelectRegistryPropertyIterateDispose = 20,
  194.     kSelectRegistryPropertyIterate = 21,
  195.     kSelectRegistryPropertyGetSize = 22,
  196.     kSelectRegistryPropertyGet  = 23,
  197.     kSelectRegistryPropertySet  = 24,
  198.     kSelectRegistryEntryGetMod  = 25,
  199.     kSelectRegistryEntrySetMod  = 26,
  200.     kSelectRegistryPropertyGetMod = 27,
  201.     kSelectRegistryPropertySetMod = 28,
  202.     kSelectRegistryEntryMod     = 29,
  203.     kSelectRegistryEntryPropertyMod = 30,                       /* if you add more selectors here, remember to change 'kSelectRegistryHighestSelector' below*/
  204.     kSelectRegistryHighestSelector = kSelectRegistryEntryPropertyMod
  205. };
  208. /* ///////////////////////
  209. //
  210. // Entry Management
  211. //
  212. /////////////////////// */
  214. /*-------------------------------
  215.  * EntryID handling
  216.  */
  217. /*
  218.  * Initialize an EntryID to a known invalid state
  219.  *   note: invalid != uninitialized
  220.  */
  221. #if CALL_NOT_IN_CARBON
  222. EXTERN_API_C( OSStatus )
  223. RegistryEntryIDInit             (RegEntryID *           id)                                 TWOWORDINLINE(0x7000, 0xABE9);
  225. /*
  226.  * Compare EntryID's for equality or if invalid
  227.  *
  228.  * If a NULL value is given for either id1 or id2, the other id 
  229.  * is compared with an invalid ID.  If both are NULL, the id's 
  230.  * are consided equal (result = true). 
  231.  */
  232. EXTERN_API_C( Boolean )
  233. RegistryEntryIDCompare          (const RegEntryID *     id1,
  234.                                  const RegEntryID *     id2)                                TWOWORDINLINE(0x7001, 0xABE9);
  236. /*
  237.  * Copy an EntryID
  238.  */
  239. EXTERN_API_C( OSStatus )
  240. RegistryEntryIDCopy             (const RegEntryID *     src,
  241.                                  RegEntryID *           dst)                                TWOWORDINLINE(0x7002, 0xABE9);
  243. /*
  244.  * Free an ID so it can be reused.
  245.  */
  246. EXTERN_API_C( OSStatus )
  247. RegistryEntryIDDispose          (RegEntryID *           id)                                 TWOWORDINLINE(0x7003, 0xABE9);
  249. /*-------------------------------
  250.  * Adding and removing entries
  251.  *
  252.  * If (parentEntry) is NULL, the name is assumed
  253.  * to be a rooted path. It is rooted to an anonymous, unnamed root.
  254.  */
  255. EXTERN_API_C( OSStatus )
  256. RegistryCStrEntryCreate         (const RegEntryID *     parentEntry,
  257.                                  const RegCStrPathName * name,
  258.                                  RegEntryID *           newEntry)                           TWOWORDINLINE(0x7004, 0xABE9);
  260. EXTERN_API_C( OSStatus )
  261. RegistryEntryDelete             (const RegEntryID *     id)                                 TWOWORDINLINE(0x7005, 0xABE9);
  263. EXTERN_API_C( OSStatus )
  264. RegistryEntryCopy               (RegEntryID *           parentEntryID,
  265.                                  RegEntryID *           sourceDevice,
  266.                                  RegEntryID *           destDevice)                         TWOWORDINLINE(0x7006, 0xABE9);
  268. /*---------------------------
  269.  * Traversing the namespace
  270.  *
  271.  * To support arbitrary namespace implementations in the future,
  272.  * I have hidden the form that the place pointer takes.  The previous
  273.  * interface exposed the place pointer by specifying it as a
  274.  * RegEntryID.
  275.  *
  276.  * I have also removed any notion of returning the entries
  277.  * in a particular order, because an implementation might
  278.  * return the names in semi-random order.  Many name service
  279.  * implementations will store the names in a hashed lookup
  280.  * table.
  281.  *
  282.  * Writing code to traverse some set of names consists of
  283.  * a call to begin the iteration, the iteration loop, and
  284.  * a call to end the iteration.  The begin call initializes
  285.  * the iteration cookie data structure.  The call to end the 
  286.  * iteration should be called even in the case of error so 
  287.  * that allocated data structures can be freed.
  288.  *
  289.  *  Create(...)
  290.  *  do {
  291.  *      Iterate(...);
  292.  *  } while (!done);
  293.  *  Dispose(...);
  294.  *
  295.  * This is the basic code structure for callers of the iteration
  296.  * interface.
  297.  */
  298. #endif  /* CALL_NOT_IN_CARBON */
  300. typedef struct OpaqueRegEntryIter*      RegEntryIter;
  301. /* 
  302.  * create/dispose the iterator structure
  303.  *   defaults to root with relationship = kRegIterDescendants
  304.  */
  305. #if CALL_NOT_IN_CARBON
  306. EXTERN_API_C( OSStatus )
  307. RegistryEntryIterateCreate      (RegEntryIter *         cookie)                             TWOWORDINLINE(0x7007, 0xABE9);
  309. EXTERN_API_C( OSStatus )
  310. RegistryEntryIterateDispose     (RegEntryIter *         cookie)                             TWOWORDINLINE(0x7008, 0xABE9);
  312. /* 
  313.  * set Entry Iterator to specified entry
  314.  */
  315. EXTERN_API_C( OSStatus )
  316. RegistryEntryIterateSet         (RegEntryIter *         cookie,
  317.                                  const RegEntryID *     startEntryID)                       TWOWORDINLINE(0x7009, 0xABE9);
  319. /*
  320.  * Return each value of the iteration
  321.  *
  322.  * return entries related to the current entry
  323.  * with the specified relationship
  324.  */
  325. EXTERN_API_C( OSStatus )
  326. RegistryEntryIterate            (RegEntryIter *         cookie,
  327.                                  RegEntryIterationOp    relationship,
  328.                                  RegEntryID *           foundEntry,
  329.                                  Boolean *              done)                               TWOWORDINLINE(0x700A, 0xABE9);
  331. /*
  332.  * return entries with the specified property
  333.  *
  334.  * A NULL RegPropertyValue pointer will return an
  335.  * entry with the property containing any value.
  336.  */
  337. EXTERN_API_C( OSStatus )
  338. RegistryEntrySearch             (RegEntryIter *         cookie,
  339.                                  RegEntryIterationOp    relationship,
  340.                                  RegEntryID *           foundEntry,
  341.                                  Boolean *              done,
  342.                                  const RegPropertyName * propertyName,
  343.                                  const void *           propertyValue,
  344.                                  RegPropertyValueSize   propertySize)                       TWOWORDINLINE(0x700B, 0xABE9);
  346. /*--------------------------------
  347.  * Find a name in the namespace
  348.  *
  349.  * This is the fast lookup mechanism.
  350.  * NOTE:  A reverse lookup mechanism
  351.  *    has not been provided because
  352.  *        some name services may not
  353.  *        provide a fast, general reverse
  354.  *        lookup.
  355.  */
  356. EXTERN_API_C( OSStatus )
  357. RegistryCStrEntryLookup         (const RegEntryID *     searchPointID,
  358.                                  const RegCStrPathName * pathName,
  359.                                  RegEntryID *           foundEntry)                         TWOWORDINLINE(0x700C, 0xABE9);
  361. /*---------------------------------------------
  362.  * Convert an entry to a rooted name string
  363.  *
  364.  * A utility routine to turn an Entry ID
  365.  * back into a name string.
  366.  */
  367. EXTERN_API_C( OSStatus )
  368. RegistryEntryToPathSize         (const RegEntryID *     entryID,
  369.                                  RegPathNameSize *      pathSize)                           TWOWORDINLINE(0x700D, 0xABE9);
  371. EXTERN_API_C( OSStatus )
  372. RegistryCStrEntryToPath         (const RegEntryID *     entryID,
  373.                                  RegCStrPathName *      pathName,
  374.                                  RegPathNameSize        pathSize)                           TWOWORDINLINE(0x700E, 0xABE9);
  376. /*
  377.  * Parse a path name.
  378.  *
  379.  * Retrieve the last component of the path, and
  380.  * return a spec for the parent.
  381.  */
  382. EXTERN_API_C( OSStatus )
  383. RegistryCStrEntryToName         (const RegEntryID *     entryID,
  384.                                  RegEntryID *           parentEntry,
  385.                                  RegCStrEntryName *     nameComponent,
  386.                                  Boolean *              done)                               TWOWORDINLINE(0x700F, 0xABE9);
  388. /* //////////////////////////////////////////////////////
  389. //
  390. // Property Management
  391. //
  392. ////////////////////////////////////////////////////// */
  393. /*-------------------------------
  394.  * Adding and removing properties
  395.  */
  396. EXTERN_API_C( OSStatus )
  397. RegistryPropertyCreate          (const RegEntryID *     entryID,
  398.                                  const RegPropertyName * propertyName,
  399.                                  const void *           propertyValue,
  400.                                  RegPropertyValueSize   propertySize)                       TWOWORDINLINE(0x7010, 0xABE9);
  402. EXTERN_API_C( OSStatus )
  403. RegistryPropertyDelete          (const RegEntryID *     entryID,
  404.                                  const RegPropertyName * propertyName)                      TWOWORDINLINE(0x7011, 0xABE9);
  406. EXTERN_API_C( OSStatus )
  407. RegistryPropertyRename          (const RegEntryID *     entry,
  408.                                  const RegPropertyName * oldName,
  409.                                  const RegPropertyName * newName)                           TWOWORDINLINE(0x7012, 0xABE9);
  411. /*---------------------------
  412.  * Traversing the Properties of a name
  413.  *
  414.  */
  415. #endif  /* CALL_NOT_IN_CARBON */
  417. typedef struct OpaqueRegPropertyIter*   RegPropertyIter;
  418. #if CALL_NOT_IN_CARBON
  419. EXTERN_API_C( OSStatus )
  420. RegistryPropertyIterateCreate   (const RegEntryID *     entry,
  421.                                  RegPropertyIter *      cookie)                             TWOWORDINLINE(0x7013, 0xABE9);
  423. EXTERN_API_C( OSStatus )
  424. RegistryPropertyIterateDispose  (RegPropertyIter *      cookie)                             TWOWORDINLINE(0x7014, 0xABE9);
  426. EXTERN_API_C( OSStatus )
  427. RegistryPropertyIterate         (RegPropertyIter *      cookie,
  428.                                  RegPropertyName *      foundProperty,
  429.                                  Boolean *              done)                               TWOWORDINLINE(0x7015, 0xABE9);
  431. /*
  432.  * Get the value of the specified property for the specified entry.
  433.  *
  434.  */
  435. EXTERN_API_C( OSStatus )
  436. RegistryPropertyGetSize         (const RegEntryID *     entryID,
  437.                                  const RegPropertyName * propertyName,
  438.                                  RegPropertyValueSize * propertySize)                       TWOWORDINLINE(0x7016, 0xABE9);
  440. /*
  441.  * (*propertySize) is the maximum size of the value returned in the buffer
  442.  * pointed to by (propertyValue).  Upon return, (*propertySize) is the size of the
  443.  * value returned.
  444.  */
  445. EXTERN_API_C( OSStatus )
  446. RegistryPropertyGet             (const RegEntryID *     entryID,
  447.                                  const RegPropertyName * propertyName,
  448.                                  void *                 propertyValue,
  449.                                  RegPropertyValueSize * propertySize)                       TWOWORDINLINE(0x7017, 0xABE9);
  451. EXTERN_API_C( OSStatus )
  452. RegistryPropertySet             (const RegEntryID *     entryID,
  453.                                  const RegPropertyName * propertyName,
  454.                                  const void *           propertyValue,
  455.                                  RegPropertyValueSize   propertySize)                       TWOWORDINLINE(0x7018, 0xABE9);
  457. /* //////////////////////////////////////////////////////
  458. //
  459. // Modifier Management
  460. //
  461. ////////////////////////////////////////////////////// */
  462. /*
  463.  * Modifiers describe special characteristics of names
  464.  * and properties.  Modifiers might be supported for
  465.  * some names and not others.
  466.  * 
  467.  * Device Drivers should not rely on functionality
  468.  * specified as a modifier.  These interfaces
  469.  * are for use in writing Experts.
  470.  */
  471. /*
  472.  * Get and Set operators for entry modifiers
  473.  */
  474. EXTERN_API_C( OSStatus )
  475. RegistryEntryGetMod             (const RegEntryID *     entry,
  476.                                  RegEntryModifiers *    modifiers)                          TWOWORDINLINE(0x7019, 0xABE9);
  478. EXTERN_API_C( OSStatus )
  479. RegistryEntrySetMod             (const RegEntryID *     entry,
  480.                                  RegEntryModifiers      modifiers)                          TWOWORDINLINE(0x701A, 0xABE9);
  482. /*
  483.  * Get and Set operators for property modifiers
  484.  */
  485. EXTERN_API_C( OSStatus )
  486. RegistryPropertyGetMod          (const RegEntryID *     entry,
  487.                                  const RegPropertyName * name,
  488.                                  RegPropertyModifiers * modifiers)                          TWOWORDINLINE(0x701B, 0xABE9);
  490. EXTERN_API_C( OSStatus )
  491. RegistryPropertySetMod          (const RegEntryID *     entry,
  492.                                  const RegPropertyName * name,
  493.                                  RegPropertyModifiers   modifiers)                          TWOWORDINLINE(0x701C, 0xABE9);
  495. /*
  496.  * Iterator operator for entry modifier search
  497.  */
  498. EXTERN_API_C( OSStatus )
  499. RegistryEntryMod                (RegEntryIter *         cookie,
  500.                                  RegEntryIterationOp    relationship,
  501.                                  RegEntryID *           foundEntry,
  502.                                  Boolean *              done,
  503.                                  RegEntryModifiers      matchingModifiers)                  TWOWORDINLINE(0x701D, 0xABE9);
  505. /*
  506.  * Iterator operator for entries with matching 
  507.  * property modifiers
  508.  */
  509. EXTERN_API_C( OSStatus )
  510. RegistryEntryPropertyMod        (RegEntryIter *         cookie,
  511.                                  RegEntryIterationOp    relationship,
  512.                                  RegEntryID *           foundEntry,
  513.                                  Boolean *              done,
  514.                                  RegPropertyModifiers   matchingModifiers)                  TWOWORDINLINE(0x701E, 0xABE9);
  517. #endif  /* CALL_NOT_IN_CARBON */
  520. #if PRAGMA_STRUCT_ALIGN
  521.     #pragma options align=reset
  522. #elif PRAGMA_STRUCT_PACKPUSH
  523.     #pragma pack(pop)
  524. #elif PRAGMA_STRUCT_PACK
  525.     #pragma pack()
  526. #endif
  528. #ifdef PRAGMA_IMPORT_OFF
  529. #pragma import off
  530. #elif PRAGMA_IMPORT
  531. #pragma import reset
  532. #endif
  534. #ifdef __cplusplus
  535. }
  536. #endif
  538. #endif /* __NAMEREGISTRY__ */