include/realmedia/rmamon.h

   1 /****************************************************************************
   2  *
   3  *  $Id: rmamon.h 7 2003-05-30 02:18:02Z gabest $
   4  *
   5  *  Copyright (C) 1995-1999 RealNetworks, Inc. All rights reserved.
   6  *
   7  *  http://www.real.com/devzone
   8  *
   9  *  This program contains proprietary
  10  *  information of Progressive Networks, Inc, and is licensed
  11  *  subject to restrictions on use and distribution.
  12  *
  13  *
  14  *  RealMedia Architecture Registry Interfaces.
  15  *
  16  */
  17
  18 #ifndef _RMAMON_H_
  19 #define _RMAMON_H_
  20
  21 typedef _INTERFACE      IUnknown                        IUnknown;
  22 typedef _INTERFACE      IRMAPlugin                      IRMAPlugin;
  23 typedef _INTERFACE      IRMABuffer                      IRMABuffer;
  24 typedef _INTERFACE      IRMAValues                      IRMAValues;
  25 typedef _INTERFACE      IRMAPropWatch                   IRMAPropWatch;
  26 typedef _INTERFACE      IRMAPropWatchResponse           IRMAPropWatchResponse;
  27 typedef _INTERFACE      IRMAActiveRegistry              IRMAActiveRegistry;
  28 typedef _INTERFACE      IRMAActivePropUser              IRMAActivePropUser;
  29 typedef _INTERFACE      IRMAActivePropUserResponse      IRMAActivePropUserResponse;
  30 typedef _INTERFACE      IRMAPNRegistryAltStringHandling IRMAPNRegistryAltStringHandling;
  31
  32 /*
  33  * Types of the values stored in the registry.
  34  */
  35 typedef enum _RMAPropType
  36 {
  37     PT_UNKNOWN,
  38     PT_COMPOSITE,       /* Contains other values (elements)                  */
  39     PT_INTEGER,         /* 32-bit signed value                               */
  40     PT_INTREF,          /* Integer reference object -- 32-bit signed integer */
  41     PT_STRING,          /* Signed char* value                                */
  42     PT_BUFFER           /* IRMABuffer object                                 */
  43 } RMAPropType;
  44
  45
  46 /*
  47  *
  48  *  Interface:
  49  *
  50  *      IRMAPNRegistry
  51  *
  52  *  Purpose:
  53  *
  54  *      This inteface provides access to the "Registry" in the server and
  55  *      client.  The "Registry" is a hierarchical structure of Name/Value
  56  *      pairs (properties) which is capable of storing many different types
  57  *      of data including strings, buffers, and integers.  The registry
  58  *      provides various types of information including statistics,
  59  *      configuration information, and system status.
  60  *
  61  *      Note:  This registry is not related to the Windows system registry.
  62  *
  63  *  IID_IRMAPNRegistry:
  64  *
  65  *      {00000600-0901-11d1-8B06-00A024406D59}
  66  *
  67  */
  68 DEFINE_GUID(IID_IRMAPNRegistry, 0x00000600, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  69                         0xa0, 0x24, 0x40, 0x6d, 0x59);
  70
  71 #define CLSID_IRMAPNRegistry    IID_IRMAPNRegistry
  72
  73 #undef  INTERFACE
  74 #define INTERFACE   IRMAPNRegistry
  75
  76 DECLARE_INTERFACE_(IRMAPNRegistry, IUnknown)
  77 {
  78     /*
  79      *  IUnknown methods
  80      */
  81     STDMETHOD(QueryInterface)   (THIS_
  82                                 REFIID riid,
  83                                 void** ppvObj) PURE;
  84
  85     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
  86
  87     STDMETHOD_(ULONG,Release)   (THIS) PURE;
  88
  89     /*
  90      *  IRMAPNRegistry methods
  91      */
  92
  93     /************************************************************************
  94      *  Method:
  95      *      IRMAPNRegistry::CreatePropWatch
  96      *  Purpose:
  97      *      Create a new IRMAPropWatch object which can then be queried for
  98      *  the right kind of IRMAPropWatch object.
  99      *
 100      *  pPropWatch - OUT - returns a new addref'ed IRMAPropWatch object
 101      */
 102     STDMETHOD(CreatePropWatch)          (THIS_
 103                                         REF(IRMAPropWatch*) pPropWatch) PURE;
 104
 105     /************************************************************************
 106      *  Method:
 107      *      IRMAPNRegistry::AddComp
 108      *  Purpose:
 109      *      Add a COMPOSITE property to the registry and return its ID
 110      *  if successful. It returns ZERO (0) if an error occurred
 111      *  during the operation.
 112      *
 113      *  pName - IN - name of the Property that is going to be added to
 114      *               the registry
 115      */
 116     STDMETHOD_(UINT32, AddComp)         (THIS_
 117                                         const char*     pName) PURE;
 118
 119     /************************************************************************
 120      *  Method:
 121      *      IRMAPNRegistry::AddInt
 122      *  Purpose:
 123      *      Add an INTEGER property with name in "pName" and value in
 124      *  "iValue" to the registry. The return value is the id to
 125      *  the newly added Property or ZERO if there was an error.
 126      *
 127      *  pName - IN - name of the Property that is going to be added to
 128      *               the registry
 129      *  nValue - IN - integer value of the Property that is going to be
 130      *                added to the registry
 131      */
 132     STDMETHOD_(UINT32, AddInt)          (THIS_
 133                                         const char*     pName,
 134                                         const INT32     nValue) PURE;
 135
 136     /************************************************************************
 137      *  Method:
 138      *      IRMAPNRegistry::GetIntByName
 139      *  Purpose:
 140      *      Retreive an INTEGER value from the registry given its Property
 141      *  name "pName". If the Property is found, it will return PNR_OK,
 142      *  otherwise it returns PNR_FAIL.
 143      *
 144      *  pName - IN - name of the Property whose value is to be retreived
 145      *  nValue - OUT - parameter into which the value of the Property is
 146      *                 going to be returned
 147      */
 148     STDMETHOD(GetIntByName)             (THIS_
 149                                         const char*     pName,
 150                                         REF(INT32)      nValue) const PURE;
 151
 152     /************************************************************************
 153      *  Method:
 154      *      IRMAPNRegistry::GetIntById
 155      *  Purpose:
 156      *      Retreive an INTEGER value from the registry given its id "ulId".
 157      *  If the Property is found, it will return PNR_OK, otherwise it
 158      *  returns PNR_FAIL.
 159      *
 160      *  ulId - IN - unique id of the Property whose value is to be retreived
 161      *  nValue - OUT - parameter into which the value of the Property is
 162      *                 going to be returned
 163      */
 164     STDMETHOD(GetIntById)               (THIS_
 165                                         const UINT32    ulId,
 166                                         REF(INT32)      nValue) const PURE;
 167
 168     /************************************************************************
 169      *  Method:
 170      *      IRMAPNRegistry::SetIntByName
 171      *  Purpose:
 172      *      Modify a Property's INTEGER value in the registry given the
 173      *  Property's name "pName". If the value was set, it will return PNR_OK,
 174      *  otherwise it returns PNR_FAIL.
 175      *
 176      *  pName - IN - name of the Property whose value is to be set
 177      *  nValue - IN - the new value of the Property which is going to be set
 178      */
 179     STDMETHOD(SetIntByName)             (THIS_
 180                                         const char*     pName,
 181                                         const INT32     nValue) PURE;
 182
 183     /************************************************************************
 184      *  Method:
 185      *      IRMAPNRegistry::SetIntById
 186      *  Purpose:
 187      *      Modify a Property's INTEGER value in the registry given the
 188      *  its id "id". If the value was set, it will return PNR_OK, otherwise
 189      *  it returns PNR_FAIL.
 190      *
 191      *  ulId - IN - unique id of the Property whose value is to be set
 192      *  nValue - IN - the new value of the Property which is going to be set
 193      */
 194     STDMETHOD(SetIntById)               (THIS_
 195                                         const UINT32    id,
 196                                         const INT32     nValue) PURE;
 197
 198     /************************************************************************
 199      *  Method:
 200      *      IRMAPNRegistry::AddStr
 201      *  Purpose:
 202      *      Add an STRING property with name in "pName" and value in
 203      *  "pValue" to the registry.
 204      *
 205      *  pName - IN - name of the Property that is going to be added to
 206      *               the registry
 207      *  pValue - IN - buffer value of the Property that is going to be
 208      *                added to the registry
 209      */
 210     STDMETHOD_(UINT32, AddStr)          (THIS_
 211                                         const char*     pName,
 212                                         IRMABuffer*     pValue) PURE;
 213
 214     /************************************************************************
 215      *  Method:
 216      *      IRMAPNRegistry::GetStrByName
 217      *  Purpose:
 218      *      Retreive an STRING value from the registry given its Property
 219      *  name "pName". If the Property is found, it will return PNR_OK,
 220      *  otherwise it returns PNR_FAIL.
 221      *
 222      *  pName - IN - name of the Property whose value is to be retreived
 223      *  pValue - OUT - parameter into which the value of the Property is
 224      *                 going to be returned
 225      */
 226     STDMETHOD(GetStrByName)             (THIS_
 227                                         const char*      pName,
 228                                         REF(IRMABuffer*) pValue) const PURE;
 229
 230     /************************************************************************
 231      *  Method:
 232      *      IRMAPNRegistry::GetStrById
 233      *  Purpose:
 234      *      Retreive an STRING value from the registry given its id "ulId".
 235      *  If the Property is found, it will return PNR_OK, otherwise it
 236      *  returns PNR_FAIL.
 237      *
 238      *  ulId - IN - unique id of the Property whose value is to be retreived
 239      *  pValue - OUT - parameter into which the value of the Property is
 240      *                 going to be returned
 241      */
 242     STDMETHOD(GetStrById)               (THIS_
 243                                         const UINT32     ulId,
 244                                         REF(IRMABuffer*) pValue) const PURE;
 245
 246     /************************************************************************
 247      *  Method:
 248      *      IRMAPNRegistry::SetStrByName
 249      *  Purpose:
 250      *      Modify a Property's STRING value in the registry given the
 251      *  Property's name "pName". If the value was set, it will return
 252      *  PNR_OK, otherwise it returns PNR_FAIL.
 253      *
 254      *  pName - IN - name of the Property whose value is to be set
 255      *  pValue - IN - the new value of the Property which is going to be set
 256      */
 257     STDMETHOD(SetStrByName)             (THIS_
 258                                         const char*     pName,
 259                                         IRMABuffer*     pValue) PURE;
 260
 261     /************************************************************************
 262      *  Method:
 263      *      IRMAPNRegistry::SetStrById
 264      *  Purpose:
 265      *      Modify a Property's STRING value in the registry given the
 266      *  its id "ulId". If the value was set, it will return PNR_OK,
 267      *  otherwise it returns PNR_FAIL.
 268      *
 269      *  ulId - IN - unique id of the Property whose value is to be set
 270      *  pValue - IN - the new value of the Property which is going to be set
 271      */
 272     STDMETHOD(SetStrById)               (THIS_
 273                                         const UINT32    ulId,
 274                                         IRMABuffer*     pValue) PURE;
 275
 276     /************************************************************************
 277      *  Method:
 278      *      IRMAPNRegistry::AddBuf
 279      *  Purpose:
 280      *      Add an BUFFER property with name in "pName" and value in
 281      *  "pValue" to the registry.
 282      *
 283      *  pName - IN - name of the Property that is going to be added to
 284      *               the registry
 285      *  pValue - IN - buffer value of the Property that is going to be
 286      *                added to the registry
 287      */
 288     STDMETHOD_(UINT32, AddBuf)          (THIS_
 289                                         const char*     pName,
 290                                         IRMABuffer*     pValue) PURE;
 291
 292     /************************************************************************
 293      *  Method:
 294      *      IRMAPNRegistry::GetBufByName
 295      *  Purpose:
 296      *      Retreive the BUFFER from the registry given its Property name
 297      *  "pName". If the Property is found, it will return PNR_OK, otherwise
 298      *  it returns PNR_FAIL.
 299      *
 300      *  pName - IN - name of the Property whose value is to be retreived
 301      *  pValue - OUT - parameter into which the value of the Property is
 302      *                 going to be returned
 303      */
 304     STDMETHOD(GetBufByName)             (THIS_
 305                                         const char*      pName,
 306                                         REF(IRMABuffer*) pValue) const PURE;
 307
 308     /************************************************************************
 309      *  Method:
 310      *      IRMAPNRegistry::GetBufById
 311      *  Purpose:
 312      *      Retreive the BUFFER from the registry given its id "ulId". If the
 313      *  Property is found, it will return PNR_OK, otherwise it returns
 314      *  PNR_FAIL.
 315      *
 316      *  ulId - IN - unique id of the Property whose value is to be retreived
 317      *  pValue - OUT - parameter into which the value of the Property is
 318      *                 going to be returned
 319      */
 320     STDMETHOD(GetBufById)               (THIS_
 321                                         const UINT32     ulId,
 322                                         REF(IRMABuffer*) pValue) const PURE;
 323
 324     /************************************************************************
 325      *  Method:
 326      *      IRMAPNRegistry::SetBufByName
 327      *  Purpose:
 328      *      Modify a Property's BUFFER in the registry given the
 329      *  Property's name "pName". If the value was set, it will return
 330      *  PNR_OK, otherwise it returns PNR_FAIL.
 331      *
 332      *  pName - IN - name of the Property whose value is to be set
 333      *  pValue - IN - the new value of the Property which is going to be set
 334      */
 335     STDMETHOD(SetBufByName)             (THIS_
 336                                         const char*     pName,
 337                                         IRMABuffer*     pValue) PURE;
 338
 339     /************************************************************************
 340      *  Method:
 341      *      IRMAPNRegistry::SetBufById
 342      *  Purpose:
 343      *      Modify a Property's BUFFER in the registry given its id "ulId".
 344      *  If the value was set, it will return PNR_OK, otherwise it returns
 345      *  PNR_FAIL.
 346      *
 347      *  ulId - IN - unique id of the Property whose value is to be set
 348      *  pValue - IN - the new value of the Property which is going to be set
 349      */
 350     STDMETHOD(SetBufById)               (THIS_
 351                                         const UINT32    ulId,
 352                                         IRMABuffer*     pValue) PURE;
 353
 354     /************************************************************************
 355      *  Method:
 356      *      IRMAPNRegistry::AddIntRef
 357      *  Purpose:
 358      *      Add an INTEGER REFERENCE property with name in "pName" and
 359      *  value in "iValue" to the registry. This property allows the user
 360      *  to modify its contents directly, without having to go through the
 361      *  registry.
 362      *
 363      *  pName - IN - name of the Property that is going to be added to
 364      *               the registry
 365      *  pValue - IN - the pointer of the integer value is what gets stored
 366      *                in the registry as the Interger Reference Property's
 367      *                value
 368      */
 369     STDMETHOD_(UINT32, AddIntRef)       (THIS_
 370                                         const char*     pName,
 371                                         INT32*          pValue) PURE;
 372
 373     /************************************************************************
 374      *  Method:
 375      *      IRMAPNRegistry::DeleteByName
 376      *  Purpose:
 377      *      Delete a Property from the registry using its name "pName".
 378      *
 379      *  pName - IN - name of the Property that is going to be deleted
 380      */
 381     STDMETHOD_(UINT32, DeleteByName)    (THIS_
 382                                         const char*     pName) PURE;
 383
 384     /************************************************************************
 385      *  Method:
 386      *      IRMAPNRegistry::DeleteById
 387      *  Purpose:
 388      *      Delete a Property from the registry using its id "ulId".
 389      *
 390      *  ulId - IN - unique id of the Property that is going to be deleted
 391      */
 392     STDMETHOD_(UINT32, DeleteById)      (THIS_
 393                                         const UINT32    ulId) PURE;
 394
 395     /************************************************************************
 396      *  Method:
 397      *      IRMAPNRegistry::GetTypeByName
 398      *  Purpose:
 399      *      Returns the datatype of the Property given its name "pName".
 400      *
 401      *  pName - IN - name of the Property whose type is to be retreived
 402      */
 403     STDMETHOD_(RMAPropType, GetTypeByName)      (THIS_
 404                                                 const char* pName) const PURE;
 405
 406     /************************************************************************
 407      *  Method:
 408      *      IRMAPNRegistry::GetTypeById
 409      *  Purpose:
 410      *      Returns the datatype of the Property given its its id "ulId".
 411      *
 412      *  ulId - IN - unique id of the Property whose type is to be retreived
 413      */
 414     STDMETHOD_(RMAPropType, GetTypeById)        (THIS_
 415                                                 const UINT32 ulId) const PURE;
 416
 417     /************************************************************************
 418      *  Method:
 419      *      IRMAPNRegistry::FindParentIdByName
 420      *  Purpose:
 421      *      Returns the id value of the parent node of the Property whose
 422      *  name "pName" has been passed in. If it fails, a ZERO value is
 423      *  returned.
 424      *
 425      *  pName - IN - name of the Property whose parent's unique id is to be
 426      *               retreived
 427      */
 428     STDMETHOD_(UINT32, FindParentIdByName)      (THIS_
 429                                                 const char* pName) const PURE;
 430
 431     /************************************************************************
 432      *  Method:
 433      *      IRMAPNRegistry::FindParentIdById
 434      *  Purpose:
 435      *      Returns the id value of the parent node of the Property whose
 436      *  id "ulId" has been passed in. If it fails, a ZERO value is returned.
 437      *
 438      *  ulId - IN - unique id of the Property whose parent's id is to be
 439      *              retreived
 440      */
 441     STDMETHOD_(UINT32, FindParentIdById)        (THIS_
 442                                                 const UINT32 ulId) const PURE;
 443
 444     /************************************************************************
 445      *  Method:
 446      *      PNRegistry::GetPropName
 447      *  Purpose:
 448      *      Returns the Property name in the pName char buffer passed
 449      *  as a parameter, given the Property's id "ulId".
 450      *
 451      *  ulId - IN - unique id of the Property whose name is to be retreived
 452      *  pName - OUT - parameter into which the Property name is going to be
 453      *                returned
 454      */
 455     STDMETHOD(GetPropName)              (THIS_
 456                                         const UINT32 ulId,
 457                                         REF(IRMABuffer*) pName) const PURE;
 458
 459     /************************************************************************
 460      *  Method:
 461      *      PNRegistry::GetId
 462      *  Purpose:
 463      *      Returns the Property's id given the Property name.
 464      *
 465      *  pName - IN - name of the Property whose unique id is to be
 466      *               retreived
 467      */
 468     STDMETHOD_(UINT32, GetId)           (THIS_
 469                                         const char* pName) const PURE;
 470
 471     /************************************************************************
 472      *  Method:
 473      *      IRMAPNRegistry::GetPropListOfRoot
 474      *  Purpose:
 475      *      Returns an array of a Properties under the root level of the
 476      *  registry's hierarchy.
 477      *
 478      *  pValues - OUT - list of property name and unique id at the
 479      *                  highest level (root) in the registry
 480      */
 481     STDMETHOD(GetPropListOfRoot)        (THIS_
 482                                         REF(IRMAValues*) pValues) const PURE;
 483
 484     /************************************************************************
 485      *  Method:
 486      *      IRMAPNRegistry::GetPropListByName
 487      *  Purpose:
 488      *      Returns an array of Properties immediately under the one whose
 489      *  name is passed in "pName".
 490      *
 491      *  pName - IN - name of the Property whose child property list is to be
 492      *               retreived
 493      *  pValues - OUT - list of property name and unique id under the
 494      *                  Property whose name is in "pName"
 495      */
 496     STDMETHOD(GetPropListByName)        (THIS_
 497                                          const char* pName,
 498                                          REF(IRMAValues*) pValues) const PURE;
 499
 500     /************************************************************************
 501      *  Method:
 502      *      IRMAPNRegistry::GetPropListById
 503      *  Purpose:
 504      *      Returns an array of Properties immediately under the one whose
 505      *  id is passed in "ulId".
 506      *
 507      *  ulId - IN - unique id of the Property whose child property list is
 508      *              to be retreived
 509      *  pValues - OUT - list of property name and unique id under the
 510      *                  Property whose is is in "ulId"
 511      */
 512     STDMETHOD(GetPropListById)          (THIS_
 513                                          const UINT32 ulId,
 514                                          REF(IRMAValues*) pValues) const PURE;
 515
 516     /************************************************************************
 517      *  Method:
 518      *      IRMAPNRegistry::GetNumPropsAtRoot
 519      *  Purpose:
 520      *      Returns the number of Properties at the root of the registry.
 521      */
 522     STDMETHOD_(INT32, GetNumPropsAtRoot)        (THIS) const PURE;
 523
 524     /************************************************************************
 525      *  Method:
 526      *      IRMAPNRegistry::GetNumPropsByName
 527      *  Purpose:
 528      *      Returns the count of the number of Properties under the one
 529      *  whose name is specified in "pName".
 530      *
 531      *  pName - IN - name of the Property whose number of children is to be
 532      *               retreived
 533      */
 534     STDMETHOD_(INT32, GetNumPropsByName)        (THIS_
 535                                                 const char* pName) const PURE;
 536
 537     /************************************************************************
 538      *  Method:
 539      *      IRMAPNRegistry::GetNumPropsById
 540      *  Purpose:
 541      *      Returns the count of the number of Properties under the one
 542      *  whose unique id is specified in "ulId".
 543      *
 544      *  ulId - IN - unique id of the Property whose number of children is
 545      *              to be retreived
 546      */
 547     STDMETHOD_(INT32, GetNumPropsById)          (THIS_
 548                                                 const UINT32 ulId) const PURE;
 549 };
 550
 551
 552 /*
 553  *
 554  *  Interface:
 555  *
 556  *      IRMAPropWatch
 557  *
 558  *  Purpose:
 559  *
 560  *      This interface allows the user to watch properties so that when
 561  *  changes happen to the properties the plugins receive notification via
 562  *  the IRMAPropWatchResponse API.
 563  *
 564  *  IID_IRMAPropWatch:
 565  *
 566  *      {00000601-0901-11d1-8B06-00A024406D59}
 567  *
 568  */
 569 DEFINE_GUID(IID_IRMAPropWatch, 0x00000601, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 570                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 571
 572 #undef  INTERFACE
 573 #define INTERFACE   IRMAPropWatch
 574
 575 DECLARE_INTERFACE_(IRMAPropWatch, IUnknown)
 576 {
 577     /*
 578      *  IUnknown methods
 579      */
 580     STDMETHOD(QueryInterface)   (THIS_
 581                                 REFIID riid,
 582                                 void** ppvObj) PURE;
 583
 584     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 585
 586     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 587
 588     /*
 589      *  IRMAPropWatch methods
 590      */
 591
 592     /************************************************************************
 593      *  Method:
 594      *      IRMAPropWatch::Init
 595      *  Purpose:
 596      *      Initialize with the response object so that the Watch
 597      *  notifications can be sent back to the respective plugins.
 598      *
 599      *  pResponse - IN - pointer to the response object which gets used to
 600      *                   initialize the IRMAPropWatch object. the response
 601      *                   object gets AddRef'd in the Init method.
 602      */
 603     STDMETHOD(Init)             (THIS_
 604                                 IRMAPropWatchResponse*  pResponse) PURE;
 605
 606     /************************************************************************
 607      *  Method:
 608      *      IRMAPropWatch::SetWatchOnRoot
 609      *  Purpose:
 610      *      The SetWatch method puts a watch at the highest level of
 611      *  the registry hierarchy. It notifies ONLY IF properties at THIS LEVEL
 612      *  get added/modified/deleted.
 613      */
 614     STDMETHOD_(UINT32, SetWatchOnRoot)  (THIS) PURE;
 615
 616     /************************************************************************
 617      *  Method:
 618      *      IRMAPropWatch::SetWatchByName
 619      *  Purpose:
 620      *      Sets a watch-point on the Property whose name is passed in.
 621      *  In case the mentioned Property gets modified or deleted a
 622      *  notification of that will be sent to the object which set the
 623      *  watch-point.
 624      *
 625      *  pName - IN - name of Property on which a watch point is to be added
 626      */
 627     STDMETHOD_(UINT32, SetWatchByName)  (THIS_
 628                                         const char*     pName) PURE;
 629
 630     /************************************************************************
 631      *  Method:
 632      *      IRMAPropWatch::SetWatchById
 633      *  Purpose:
 634      *      Sets a watch-point on the Property whose name is passed in.
 635      *  In case the mentioned Property gets modified or deleted a
 636      *  notification of that will be sent to the object which set the
 637      *  watch-point.
 638      *
 639      *  ulId - IN - unique id of Property on which a watch point is to be
 640      *              added
 641      */
 642     STDMETHOD_(UINT32, SetWatchById)    (THIS_
 643                                         const UINT32    ulId) PURE;
 644
 645     /************************************************************************
 646      *  Method:
 647      *      IRMAPropWatch::ClearWatchOnRoot
 648      *  Purpose:
 649      *      It clears the watch on the root of the registry.
 650      */
 651     STDMETHOD(ClearWatchOnRoot)         (THIS) PURE;
 652
 653     /************************************************************************
 654      *  Method:
 655      *      IRMAPropWatch::ClearWatchByName
 656      *  Purpose:
 657      *      Clears a watch-point based on the Property's name.
 658      *
 659      *  pName - IN - name of Property whose watch point is to be cleared
 660      */
 661     STDMETHOD(ClearWatchByName)         (THIS_
 662                                         const char*     pName) PURE;
 663
 664     /************************************************************************
 665      *  Method:
 666      *      IRMAPropWatch::ClearWatchById
 667      *  Purpose:
 668      *      Clears a watch-point based on the Property's id.
 669      *
 670      *  ulId - IN - unique id of Property whose watch point is to be cleared
 671      */
 672     STDMETHOD(ClearWatchById)           (THIS_
 673                                         const UINT32    ulId) PURE;
 674 };
 675
 676
 677 /*
 678  *
 679  *  Interface:
 680  *
 681  *      IRMAPropWatchResponse
 682  *
 683  *  Purpose:
 684  *
 685  *      Interface for notification of additions/modifications/deletions of
 686  *  properties in the registry which are being watched.
 687  *
 688  *  IID_IRMAPropWatchResponse:
 689  *
 690  *      {00000602-0901-11d1-8B06-00A024406D59}
 691  *
 692  */
 693 DEFINE_GUID(IID_IRMAPropWatchResponse, 0x00000602, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 694                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 695
 696 #undef  INTERFACE
 697 #define INTERFACE   IRMAPropWatchResponse
 698
 699 DECLARE_INTERFACE_(IRMAPropWatchResponse, IUnknown)
 700 {
 701     /*
 702      *  IUnknown methods
 703      */
 704     STDMETHOD(QueryInterface)   (THIS_
 705                                 REFIID riid,
 706                                 void** ppvObj) PURE;
 707
 708     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 709
 710     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 711
 712     /*
 713      * IRMAPropWatchResponse methods
 714      */
 715
 716     /************************************************************************
 717      *  Method:
 718      *      IRMAPropWatchResponse::AddedProp
 719      *  Purpose:
 720      *      Gets called when a new Property gets added under the Property
 721      *  on which the Watch was set. It passes the id of the Property just
 722      *  added, its datatype and the id of its immediate parent COMPOSITE
 723      *  property.
 724      */
 725     STDMETHOD(AddedProp)        (THIS_
 726                                 const UINT32            ulId,
 727                                 const RMAPropType       propType,
 728                                 const UINT32            ulParentID) PURE;
 729
 730     /************************************************************************
 731      *  Method:
 732      *      IRMAPropWatchResponse::ModifiedProp
 733      *  Purpose:
 734      *      Gets called when a watched Property gets modified. It passes
 735      *  the id of the Property just modified, its datatype and the
 736      *  id of its immediate parent COMPOSITE property.
 737      */
 738     STDMETHOD(ModifiedProp)     (THIS_
 739                                 const UINT32            ulId,
 740                                 const RMAPropType       propType,
 741                                 const UINT32            ulParentID) PURE;
 742
 743     /************************************************************************
 744      *  Method:
 745      *      IRMAPropWatchResponse::DeletedProp
 746      *  Purpose:
 747      *      Gets called when a watched Property gets deleted. As can be
 748      *  seen, it returns the id of the Property just deleted and
 749      *  its immediate parent COMPOSITE property.
 750      */
 751     STDMETHOD(DeletedProp)      (THIS_
 752                                 const UINT32            ulId,
 753                                 const UINT32            ulParentID) PURE;
 754 };
 755
 756 /*
 757  *
 758  *  Interface:
 759  *
 760  *      IRMAActiveRegistry
 761  *
 762  *  Purpose:
 763  *
 764  *      Interface to get IRMAActiveUser responsible for a particular property
 765  *  from the registry.
 766  *
 767  *  IID_IRMAActiveRegistry:
 768  *
 769  *      {00000603-0901-11d1-8B06-00A024406D59}
 770  *
 771  */
 772 DEFINE_GUID(IID_IRMAActiveRegistry, 0x00000603, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 773                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 774
 775 #undef  INTERFACE
 776 #define INTERFACE   IRMAActiveRegistry
 777
 778 DECLARE_INTERFACE_(IRMAActiveRegistry, IUnknown)
 779 {
 780     /*
 781      *  IUnknown methods
 782      */
 783     STDMETHOD(QueryInterface)   (THIS_
 784                                 REFIID riid,
 785                                 void** ppvObj) PURE;
 786
 787     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 788
 789     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 790
 791     /************************************************************************
 792     * IRMAActiveRegistry::SetAsActive
 793     *
 794     *     Method to set prop pName to active and register pUser as
 795     *   the active prop user.
 796     */
 797     STDMETHOD(SetAsActive)    (THIS_
 798                                 const char* pName,
 799                                 IRMAActivePropUser* pUser) PURE;
 800
 801     /************************************************************************
 802     * IRMAActiveRegistry::SetAsInactive
 803     *
 804     *   Method to remove an IRMAActiveUser from Prop activation.
 805     */
 806     STDMETHOD(SetAsInactive)  (THIS_
 807                                 const char* pName,
 808                                 IRMAActivePropUser* pUser) PURE;
 809
 810     /************************************************************************
 811     * IRMAActiveRegistry::IsActive
 812     *
 813     *     Tells if prop pName has an active user that must be queried to
 814     *   change the value, or if it can just be set.
 815     */
 816     STDMETHOD_(BOOL, IsActive)  (THIS_
 817                                 const char* pName) PURE;
 818
 819     /************************************************************************
 820     * IRMAActiveRegistry::SetActiveInt
 821     *
 822     *    Async request to set int pName to ul.
 823     */
 824     STDMETHOD(SetActiveInt) (THIS_
 825                             const char* pName,
 826                             UINT32 ul,
 827                             IRMAActivePropUserResponse* pResponse) PURE;
 828
 829     /************************************************************************
 830     * IRMAActiveRegistry::SetActiveStr
 831     *
 832     *    Async request to set string pName to string in pBuffer.
 833     */
 834     STDMETHOD(SetActiveStr) (THIS_
 835                             const char* pName,
 836                             IRMABuffer* pBuffer,
 837                             IRMAActivePropUserResponse* pResponse) PURE;
 838
 839     /************************************************************************
 840     * IRMAActiveRegistry::SetActiveBuf
 841     *
 842     *    Async request to set buffer pName to buffer in pBuffer.
 843     */
 844     STDMETHOD(SetActiveBuf)     (THIS_
 845                                 const char* pName,
 846                                 IRMABuffer* pBuffer,
 847                                 IRMAActivePropUserResponse* pResponse) PURE;
 848
 849     /************************************************************************
 850     * IRMAActiveRegistry::DeleteActiveProp
 851     *
 852     *   Async request to delete the active property.
 853     */
 854     STDMETHOD(DeleteActiveProp) (THIS_
 855                                 const char* pName,
 856                                 IRMAActivePropUserResponse* pResponse) PURE;
 857
 858
 859 };
 860
 861
 862 /*
 863  *
 864  *  Interface:
 865  *
 866  *      IRMAActivePropUser
 867  *
 868  *  Purpose:
 869  *
 870  *      An IRMAActivePropUser can be set as the active user of a property in
 871  *  an IRMAActiveRegistry. This causes the IRMAActivePropUser to be consulted
 872  *  everytime someone wants to change a property. The difference between this
 873  *  and a prop watch is that this is async, and can call a done method with
 874  *  failure to cause the prop to not be set, and this get called instead of
 875  *  calling into the IRMAPNReg.
 876  *
 877  *  IID_IRMAActivePropUser:
 878  *
 879  *      {00000604-0901-11d1-8B06-00A024406D59}
 880  *
 881  */
 882 DEFINE_GUID(IID_IRMAActivePropUser, 0x00000604, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 883                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 884
 885 #undef  INTERFACE
 886 #define INTERFACE   IRMAActivePropUser
 887
 888 DECLARE_INTERFACE_(IRMAActivePropUser, IUnknown)
 889 {
 890     /*
 891      *  IUnknown methods
 892      */
 893     STDMETHOD(QueryInterface)   (THIS_
 894                                 REFIID riid,
 895                                 void** ppvObj) PURE;
 896
 897     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 898
 899     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 900
 901     /************************************************************************
 902     * IRMAActivePropUser::SetActiveInt
 903     *
 904     *    Async request to set int pName to ul.
 905     */
 906     STDMETHOD(SetActiveInt) (THIS_
 907                             const char* pName,
 908                             UINT32 ul,
 909                             IRMAActivePropUserResponse* pResponse) PURE;
 910
 911     /************************************************************************
 912     * IRMAActivePropUser::SetActiveStr
 913     *
 914     *    Async request to set string pName to string in pBuffer.
 915     */
 916     STDMETHOD(SetActiveStr) (THIS_
 917                             const char* pName,
 918                             IRMABuffer* pBuffer,
 919                             IRMAActivePropUserResponse* pResponse) PURE;
 920
 921     /************************************************************************
 922     * IRMAActivePropUser::SetActiveBuf
 923     *
 924     *    Async request to set buffer pName to buffer in pBuffer.
 925     */
 926     STDMETHOD(SetActiveBuf)     (THIS_
 927                                 const char* pName,
 928                                 IRMABuffer* pBuffer,
 929                                 IRMAActivePropUserResponse* pResponse) PURE;
 930
 931     /************************************************************************
 932     * IRMAActivePropUser::DeleteActiveProp
 933     *
 934     *   Async request to delete the active property.
 935     */
 936     STDMETHOD(DeleteActiveProp) (THIS_
 937                                 const char* pName,
 938                                 IRMAActivePropUserResponse* pResponse) PURE;
 939
 940 };
 941
 942 /*
 943  *
 944  *  Interface:
 945  *
 946  *      IRMAActivePropUserResponse
 947  *
 948  *  Purpose:
 949  *
 950  *      Gets responses from IRMAActivePropUser for queries to set properties
 951  *  in the IRMAActiveRegistry.
 952  *
 953  *
 954  *  IID_IRMAActivePropUserResponse:
 955  *
 956  *      {00000605-0901-11d1-8B06-00A024406D59}
 957  *
 958  */
 959 DEFINE_GUID(IID_IRMAActivePropUserResponse, 0x00000605, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 960                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 961
 962 #undef  INTERFACE
 963 #define INTERFACE   IRMAActivePropUserResponse
 964
 965 DECLARE_INTERFACE_(IRMAActivePropUserResponse, IUnknown)
 966 {
 967     /*
 968      *  IUnknown methods
 969      */
 970     STDMETHOD(QueryInterface)   (THIS_
 971                                 REFIID riid,
 972                                 void** ppvObj) PURE;
 973
 974     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 975
 976     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 977
 978     /************************************************************************
 979     * Called with status result on completion of set request.
 980     */
 981     STDMETHOD(SetActiveIntDone)   (THIS_
 982                                     PN_RESULT res,
 983                                     const char* pName,
 984                                     UINT32 ul,
 985                                     IRMABuffer* pInfo[],
 986                                     UINT32 ulNumInfo) PURE;
 987
 988     STDMETHOD(SetActiveStrDone)   (THIS_
 989                                     PN_RESULT res,
 990                                     const char* pName,
 991                                     IRMABuffer* pBuffer,
 992                                     IRMABuffer* pInfo[],
 993                                     UINT32 ulNumInfo) PURE;
 994
 995     STDMETHOD(SetActiveBufDone)   (THIS_
 996                                     PN_RESULT res,
 997                                     const char* pName,
 998                                     IRMABuffer* pBuffer,
 999                                     IRMABuffer* pInfo[],
1000                                     UINT32 ulNumInfo) PURE;
1001
1002     STDMETHOD(DeleteActivePropDone) (THIS_
1003                                     PN_RESULT res,
1004                                     const char* pName,
1005                                     IRMABuffer* pInfo[],
1006                                     UINT32 ulNumInfo) PURE;
1007
1008 };
1009
1010 /*
1011  *
1012  *  Interface:
1013  *
1014  *      IRMACopyRegistry
1015  *
1016  *  Purpose:
1017  *
1018  *      Allows copying from one registry key to another.
1019  *
1020  *
1021  *  IID_IRMACopyRegistry
1022  *
1023  *      {00000606-0901-11d1-8B06-00A024406D59}
1024  *
1025  */
1026 DEFINE_GUID(IID_IRMACopyRegistry, 0x00000606, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1027                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1028
1029 #undef  INTERFACE
1030 #define INTERFACE   IRMACopyRegistry
1031
1032 DECLARE_INTERFACE_(IRMACopyRegistry, IUnknown)
1033 {
1034     /*
1035      *  IUnknown methods
1036      */
1037     STDMETHOD(QueryInterface)   (THIS_
1038                                 REFIID riid,
1039                                 void** ppvObj) PURE;
1040
1041     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
1042
1043     STDMETHOD_(ULONG,Release)   (THIS) PURE;
1044
1045     /************************************************************************
1046     * IRMACopyRegistry::Copy
1047     *
1048     *   Here it is! The "Copy" method!
1049     */
1050     STDMETHOD (CopyByName)  (THIS_
1051                             const char* pFrom,
1052                             const char* pTo) PURE;
1053 };
1054
1055
1056 /*
1057  *
1058  *  Interface:
1059  *
1060  *      IRMAPNRegistryAltStringHandling
1061  *
1062  *  Purpose:
1063  *
1064  *      Tells the registry about alternate handling of PT_STRING types.
1065  *
1066  *
1067  *  IID_IRMAPNRegistryAltStringHandling
1068  *
1069  *      {00000607-0901-11d1-8B06-00A024406D59}
1070  *
1071  */
1072 DEFINE_GUID(IID_IRMAPNRegistryAltStringHandling, 0x00000607, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1073                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1074
1075 #undef  INTERFACE
1076 #define INTERFACE   IRMAPNRegistryAltStringHandling
1077
1078 DECLARE_INTERFACE_(IRMAPNRegistryAltStringHandling, IUnknown)
1079 {
1080     /*
1081      *  IUnknown methods
1082      */
1083     STDMETHOD(QueryInterface)   (THIS_
1084                                 REFIID riid,
1085                                 void** ppvObj) PURE;
1086
1087     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
1088
1089     STDMETHOD_(ULONG,Release)   (THIS) PURE;
1090
1091     /************************************************************************
1092     * IRMAPNRegistryAltStringHandling::SetStringAccessAsBufferById
1093     *
1094     *   For those times when you added a property as a buffer, but wish it
1095     *   were a string (and of course, people now rely on the fact that it's
1096     *   a buffer)...  Create the property as a string and then pass this
1097     *   method it's ID.  The property will now be accessible/setable as a,
1098     *   but it will still be a string!
1099     */
1100     STDMETHOD (SetStringAccessAsBufferById)  (THIS_
1101                                               UINT32 ulId) PURE;
1102 };
1103
1104
1105 #endif /* _RMAMON_H_ */