Registrace vlastních vlastností, událostí a vzorů ovládacích prvků

Před použití vlastní vlastnosti, události nebo vzoru ovládacího prvku musí poskytovatel i klient zaregistrovat vlastnost, událost nebo vzor ovládacího prvku za běhu. Registrace je platná globálně v rámci aplikačního procesu a zůstává účinná, dokud se proces neuzavře nebo dokud není uvolněn poslední objekt elementu Microsoft UI Automation (IUIAutomation nebo IRawElementProviderSimple).

Registrace zahrnuje předání identifikátoru GUID pro automatizaci uživatelského rozhraní spolu s podrobnými informacemi o vlastní vlastnosti, události nebo vzorci ovládacího prvku. Pokus o druhou registraci stejného identifikátoru GUID se stejnými informacemi proběhne úspěšně, ale pokus o registraci stejného identifikátoru GUID podruhé, ale s různými informacemi (například vlastní vlastnost jiného typu) selže. Pokud je v budoucnu vlastní specifikace přijata a integrována do jádra automatizace uživatelského rozhraní, automatizace uživatelského rozhraní ověří vlastní registrační informace a místo "oficiální" implementace architektury použije již zaregistrovaný kód, čímž minimalizuje problémy s kompatibilitou aplikací. Nelze odebrat vlastnosti, události nebo vzory ovládacích prvků, které jsou již zaregistrovány.

Toto téma obsahuje následující části:

• Registrace Vlastních Vlastností a Událostí
• implementace vlastních vzorů ovládacích prvků
  • obálky klienta a obslužné rutiny vzoru
  • Implementace obálky klienta
  • implementace obslužné rutiny vzoru
  • Registrace vlastního ovládacího vzoru
  • příklad implementace vlastního vzoru ovládacího prvku
• související témata

Registrace vlastních vlastností a událostí

Registrace vlastní vlastnosti nebo události umožňuje poskytovateli a klientovi získat ID vlastnosti nebo události, které se pak dají předat různým metodám rozhraní API, které jako parametry přebírají ID.

Zaregistrovat vlastnost nebo událost:

1. Definujte identifikátor GUID pro vlastní vlastnost nebo událost.
2. Vyplňte UIAutomationPropertyInfo nebo UIAutomationEventInfo strukturu informacemi o vlastnosti nebo události, včetně GUID a nekonfigurovatelného řetězce, který obsahuje název vlastní vlastnosti nebo události. Vlastní vlastnosti také vyžadují, aby byl zadán datový typ vlastnosti, například zda vlastnost obsahuje celé číslo nebo řetězec. Datový typ musí být jedním z následujících typů určených výčtem UIAutomationType. Pro vlastní vlastnosti nejsou podporovány žádné jiné datové typy.
   • UIAutomationType_Bool
   • TypAutomatizaceUI_Dvojitý
   • UIAutomationType_Element
   • UIAutomationType_Int
   • UIAutomationType_Point
   • UIAutomationType_String
3. Pomocí funkce CoCreateInstance vytvořte instanci objektu CUIAutomationRegistrar a načtěte ukazatel na rozhraní IUIAutomationRegistrar objektu.
4. Zavolejte metodu IUIAutomationRegistrar::RegisterProperty nebo RegisterEvent a předejte adresu struktury UIAutomationPropertyInfo nebo UIAutomationEventInfo struktury.

Metoda IUIAutomationRegistrar::RegisterProperty nebo RegisterEvent vrátí ID vlastnosti nebo ID události, které může aplikace předat jakékoli metodě automatizace uživatelského rozhraní, která jako parametr přebírá takový identifikátor. Můžete například předat registrované ID vlastnosti metodě IUIAutomationElement::GetCurrentPropertyValue nebo metodě IUIAutomation::CreatePropertyCondition.

Následující příklad ukazuje, jak zaregistrovat uživatelskou vlastnost.

// Declare a variable for holding the custom property ID.
PATTERNID g_MyCustomPropertyID;
// Define a GUID for the custom property.
GUID GUID_MyCustomProperty = { 0x82f383ff, 0x4b4d, 0x40d3, 
    { 0x8e, 0xd2, 0x90, 0xb5, 0x25, 0x8e, 0xaa, 0x19 } };

HRESULT RegisterProperty()
{
    // Fill the structure with the GUID, name, and data type.
    UIAutomationPropertyInfo MyCustomPropertyInfo = 
    {
        GUID_MyCustomProperty,
        L"MyCustomProp",
        UIAutomationType_String
    };

    // Create the registrar object and get the IUIAutomationRegistrar 
    // interface pointer. 
    IUIAutomationRegistrar * pUIARegistrar = NULL;
    CoCreateInstance(CLSID_CUIAutomationRegistrar, NULL, CLSCTX_INPROC_SERVER, 
            IID_IUIAutomationRegistrar, (void **)&pUIARegistrar);

    if (pUIARegistrar == NULL)
        return E_NOINTERFACE;

    // Register the property and retrieve the property ID. 
    HRESULT hr = pUIARegistrar->RegisterProperty(&MyCustomPropertyInfo, &g_MyCustomPropertyID);
    pUIARegistrar->Release();

    return hr;
}

Identifikátory vlastností a událostí načtené IUIAutomationRegistrar::RegisterProperty a RegisterEvent jsou platné pouze v rámci aplikace, která je načte, a pouze po dobu, kdy je aplikace spuštěna. Metody registrace můžou vracet různé celočíselné hodnoty pro stejný identifikátor GUID, když se volá přes různé instance modulu runtime stejné aplikace.

Neexistuje žádná metoda pro zrušení registrace vlastní vlastnosti nebo události. Místo toho se při vydání posledního objektu automatizace uživatelského rozhraní implicitně zruší jejich registrace.

Důležitý

Pokud je váš kód klientem Microsoft Active Accessibility (MSAA), musíte při změně hodnoty vlastní vlastnosti volat funkci NotifyWinEvent.

 

Implementace vlastních vzorů ovládacích prvků

Vlastní vzor ovládacích prvků není součástí rozhraní API pro automatizaci uživatelského rozhraní, ale poskytuje ho třetí strana za běhu. Vývojáři klientských a zprostředkovatelů aplikací musí spolupracovat na definování vlastního vzoru ovládacích prvků, včetně metod, vlastností a událostí, které bude vzor ovládacího prvku podporovat. Po definování vzoru ovládacího prvku musí klient i poskytovatel implementovat podpůrné objekty modelu COM (Component Object Model) spolu s kódem pro registraci vzoru ovládacího prvku za běhu. Vlastní vzor ovládacího prvku vyžaduje implementaci dvou COM objektů: obal klienta a obsluhovač vzoru.

Poznámka

Příklady v následujících tématech ukazují, jak implementovat vlastní vzor ovládacího prvku, který duplikuje funkce existujícího modelu řízení hodnota. Tyto příklady jsou určené pouze pro instrukční účely. Skutečný vzor vlastního ovládacího prvku by měl poskytovat funkce, které nejsou k dispozici ze standardních vzorů ovládacích prvků automatizace uživatelského rozhraní.

 

Obálka klienta a obslužná rutina vzoru

Obálka klienta implementuje rozhraní API, které klient používá k načtení vlastností a volání metod vystavených vzorem vlastního ovládacího prvku. Rozhraní API se implementuje jako rozhraní COM, které předává všechny požadavky na vlastnosti a volání metod do jádra UI Automation, které poté zařídí jejich zaslání poskytovateli.

Kód, který registruje vlastní vzor ovládacího prvku, musí poskytnout objekt pro vytváření tříd, který může automatizace uživatelského rozhraní použít k vytvoření instancí objektu obálky klienta. Pokud je vzor vlastního ovládacího prvku úspěšně zaregistrován, vrátí Automatizace uživatelského rozhraní ukazatel rozhraní IUIAutomationPatternInstance, který klient používá k předávání požadavků na vlastnosti a volání metod do jádra automatizace uživatelského rozhraní.

Na straně zprostředkovatele základ automatizace uživatelského rozhraní přebírá požadavky na vlastnosti a volání metod od klienta a předává je do objektu zpracování vzorů. Zpracovatel vzorů pak volá příslušné metody v rozhraní zprostředkovatele pro vlastní vzor ovládacího prvku.

Kód, který registruje vlastní vzor ovládacího prvku, vytvoří objekt obslužného programu vzoru. Při registraci vzoru ovládacího prvku předá automatizaci uživatelského rozhraní ukazatel na rozhraní objektu IUIAutomationPatternHandler.

Následující diagram znázorňuje, jak požadavek na vlastnost klienta nebo volání metody probíhá z obálky klienta, prostřednictvím základních komponent UI Automation k obslužné rutině vzoru a následně směřuje k rozhraní poskytovatele.

Objekty, které implementují rozhraní klientského obalu a obsluhy vzorů, musejí být bez závislosti na vláknech. Jádro automatizace uživatelského rozhraní také musí být schopné volat objekty přímo, bez jakéhokoliv zprostředkujícího mezikódu.

Implementace obálky klienta

Obálka klienta je objekt, který zveřejňuje rozhraní IXxxPattern, které klient používá k vyžádání vlastností a volání metod podporovaných vzorem vlastního ovládacího prvku. Rozhraní se skládá z dvojice metod "getter" pro každou podporovanou vlastnost (get_CurrentXxx a metoda get_CachedXxx) a metody "volající" pro každou podporovanou metodu. Při vytvoření instance objektu obdrží konstruktor objektu ukazatel na IUIAutomationPatternInstance rozhraní, které je implementováno jádrem automatizace uživatelského rozhraní. Metody rozhraní IXxxPattern používají metody IUIAutomationPatternInstance::GetProperty a CallMethod k předávání požadavků na vlastnosti a volání metod do jádra automatizace uživatelského rozhraní.

Následující příklad ukazuje, jak implementovat objekt obálky klienta pro jednoduchý vlastní vzor ovládacího prvku, který podporuje jednu vlastnost. Složitější příklad najdete v tématu Příklad implementace vlastního vzoru ovládacího prvku.

// Define the client interface.
interface __declspec(uuid("c78b266d-b2c0-4e9d-863b-e3f74a721d47"))
IMyCustomPattern : public IUnknown
{
    STDMETHOD (get_CurrentIsReadOnly)(BOOL * pIsReadOnly) = 0;
    STDMETHOD (get_CachedIsReadOnly)(BOOL * pIsReadOnly) = 0;
};

// Implement the client wrapper class.
class CMyValuePatternClientWrapper :
    public IMyCustomPattern
{
    IUIAutomationPatternInstance * _pInstance;
    
public:
    // Get IUIAutomationPatternInstance interface pointer from the
    // UI Automation core.
    CMyValuePatternClientWrapper(IUIAutomationPatternInstance * pInstance)
        : _pInstance(pInstance)
    {
        _pInstance->AddRef();
    }
    
    ~CMyValuePatternClientWrapper()
    {
        _pInstance->Release();
    }

    // Note: Put standard IUnknown implementation here.

    STDMETHODIMP get_CurrentIsReadOnly(BOOL * pIsReadOnly)
    {
        return _pInstance->GetProperty(0, FALSE, UIAutomationType_Bool, pIsReadOnly);
    }

    STDMETHODIMP get_CachedIsReadOnly(BOOL * pIsReadOnly)
    {
        return _pInstance->GetProperty(0, TRUE, UIAutomationType_Bool, pIsReadOnly);
    }
};

Implementace správce vzoru

Zpracovatel vzoru je objekt, který implementuje rozhraní IUIAutomationPatternHandler. Toto rozhraní má dvě metody: IUIAutomationPatternHandler::CreateClientWrapper a Dispatch. Metoda CreateClientWrapper je volána jádrem automatizace uživatelského rozhraní a přijímá ukazatel na rozhraní IUIAutomationPatternInstance. CreateClientWrapper reaguje vytvořením objektu klientské obálky a předáním ukazatele rozhraní IUIAutomationPatternInstance na konstruktor klientské obálky.

Metoda Dispatch se používá jádrem automatizace uživatelského rozhraní k předávání požadavků na vlastnosti a volání metod do rozhraní zprostředkovatele pro vlastní vzor ovládacího prvku. Parametry zahrnují ukazatel na rozhraní zprostředkovatele, nulová indexová hodnota volaného getteru vlastnosti nebo metody a pole UIAutomationParameter struktury, které obsahují parametry předávané zprostředkovateli. Zpracovatel vzorů reaguje tím, že zkontroluje parametr indexu, aby určil, kterou metodu zprostředkovatele má zavolat, a poté zavolá rozhraní tohoto zprostředkovatele, přičemž předává parametry obsažené ve strukturách UIAutomationParameter.

Objekt obslužné rutiny vzoru je vytvořen stejným kódem, který zaregistruje vlastní ovládací vzor, a to ještě před jeho registrací. Kód musí předat ukazatel rozhraní objektu obslužné rutiny vzoru IUIAutomationPatternHandler k jádru automatizace uživatelského rozhraní v době registrace.

Následující příklad ukazuje, jak implementovat objekt zpracovatele vzoru pro jednoduchý vlastní ovládací vzor, který podporuje jednu vlastnost. Složitější příklad najdete v tématu Příklad implementace vlastního vzoru ovládacího prvku.

// Define the provider interface.
interface __declspec(uuid("9f5266dd-f0ab-4562-8175-c383abb2569e"))
IMyValueProvider : public IUnknown
{
    STDMETHOD (get_IsReadOnly)(BOOL * pIsReadOnly) = 0;
};            

// Index used by IUIAutomationPatternHandler::Dispatch.
const int MyValue_GetIsReadOnly = 0; 
            
// Define the pattern handler class.        
class CMyValuePatternHandler : public IUIAutomationPatternHandler
{
public:
    
    // Put standard IUnknown implementation here.

    STDMETHODIMP CreateClientWrapper(
            IUIAutomationPatternInstance * pPatternInstance, 
            IUnknown ** pClientWrapper)
    {
        *pClientWrapper = new CMyValuePatternClientWrapper(pPatternInstance);
        if (*pClientWrapper == NULL)
            return E_INVALIDARG;
        return S_OK;
    }
    
    STDMETHODIMP Dispatch (IUnknown * pTarget, UINT index, 
            const struct UIAutomationParameter *pParams, UINT cParams)
    {
        switch(index)
        {
        case MyValue_GetIsReadOnly:
            return ((IMyValueProvider*)pTarget)->get_IsReadOnly((BOOL*)pParams[0].pData);
        }
        return E_INVALIDARG;
    }
};

Registrace vlastního vzoru ovládacího prvku

Před použitím musí být vlastní vzor ovládacího prvku registrován poskytovatelem i klientem. Registrace poskytuje jádro automatizace uživatelského rozhraní s podrobnými informacemi o vzoru ovládacího prvku a poskytne poskytovateli nebo klientovi ID vzoru ovládacího prvku a ID vlastností a událostí podporovaných vzorem ovládacího prvku. Na straně poskytovatele musí být vlastní vzorec ovládání registrován dříve, než přidružený ovládací prvek zpracuje zprávu WM_GETOBJECT, nebo současně.

Při registraci vlastního vzoru ovládacího prvku poskytuje poskytovatel nebo klient následující informace:

• Identifikátor GUID vlastního vzoru ovládacího prvku.
• Nelokalizovatelný řetězec obsahující název vlastního vzoru ovládacího prvku.
• Identifikátor GUID rozhraní poskytovatele, který podporuje vlastní vzor ovládacího prvku.
• Identifikátor GUID klientského rozhraní podporující vzor vlastního ovládacího prvku.
• Pole UIAutomationPropertyInfo struktur, které popisují vlastnosti podporované vzorem vlastního ovládacího prvku. Pro každou vlastnost musí být zadán identifikátor GUID, název vlastnosti a datový typ.
• Pole struktur UIAutomationMethodInfo, které popisují metody podporované v rámci vlastního ovládacího vzoru. Pro každou metodu obsahuje struktura následující informace: název metody, počet parametrů, seznam datových typů parametrů a seznam názvů parametrů.
• Pole UIAutomationEventInfo struktur, které popisují události vyvolané uživatelským ovládacím vzorem. Pro každou událost musí být zadán identifikátor GUID a název události.
• Adresa rozhraní IUIAutomationPatternHandler objektu obsluhujícího vzor, který zpřístupňuje vlastní vzor ovládacího prvku klientům.

Pokud chcete zaregistrovat vzor vlastního ovládacího prvku, musí zprostředkovatel nebo kód klienta provést následující kroky:

1. Vyplňte UIAutomationPatternInfo strukturu pomocí předchozích informací.
2. Pomocí funkce CoCreateInstance vytvořte instanci objektu CUIAutomationRegistrar a načtěte ukazatel na rozhraní IUIAutomationRegistrar.
3. Volejte metodu IUIAutomationRegistrar::RegisterPattern a předejte adresu struktury UIAutomationPatternInfo.

Metoda RegisterPattern vrátí ID vzoru ovládacího prvku spolu se seznamem ID vlastností a ID událostí. Aplikace může tato ID předat jakékoli metodě automatizace uživatelského rozhraní, která jako parametr přebírá takový identifikátor. Například můžete předat zaregistrované ID vzoru metodě IUIAutomationElement::GetCurrentPattern k získání ukazatele na rozhraní zprostředkovatele daného ovládacího vzoru.

Neexistuje žádná metoda, která zruší registraci vlastního vzoru ovládacího prvku. Místo toho se implicitně zruší registrace při vydání posledního objektu automatizace uživatelského rozhraní.

Příklad, který ukazuje, jak zaregistrovat vlastní vzor ovládacího prvku, najdete v následující části.

Příklad implementace vlastního vzoru ovládacího prvku

Tato část obsahuje ukázkový kód, který ukazuje, jak implementovat objekty wrapperu klienta a obslužné rutiny pro vlastní vzor ovládacího prvku. Příklad implementuje vlastní vzor ovládacího prvku, který je založen na vzoru ovládacích prvků Hodnota.

// Step 1: Define the public provider and client interfaces using IDL. Interface 
// definitions are in C here to simplify the example.

// Define the provider interface.
interface __declspec(uuid("9f5266dd-f0ab-4562-8175-c383abb2569e"))
IMyValueProvider : public IUnknown
{
    STDMETHOD (get_Value)(BSTR * pValue) = 0;
    STDMETHOD (get_IsReadOnly)(BOOL * pIsReadOnly) = 0;
    STDMETHOD (SetValue)(LPCWSTR pNewValue) = 0;
    STDMETHOD (Reset)() = 0;
};

// Define the client interface.
interface __declspec(uuid("103b8323-b04a-4180-9140-8c1e437713a3"))
IUIAutomationMyValuePattern : public IUnknown
{
    STDMETHOD (get_CurrentValue)(BSTR * pValue) = 0;
    STDMETHOD (get_CachedValue)(BSTR * pValue) = 0;

    STDMETHOD (get_CurrentIsReadOnly)(BOOL * pIsReadOnly) = 0;
    STDMETHOD (get_CachedIsReadOnly)(BOOL * pIsReadOnly) = 0;

    STDMETHOD (SetValue)(LPCWSTR pNewValue) = 0;
    STDMETHOD (Reset)() = 0;
};

// Enumerate the properties and methods starting from 0, and placing the 
// properties first. 
enum
{
    MyValue_GetValue = 0,
    MyValue_GetIsReadOnly = 1,
    MyValue_SetValue = 2,
    MyValue_Reset = 3,
};

// Step 2: Implement the client wrapper class.
class CMyValuePatternClientWrapper :
    public IUIAutomationMyValuePattern
{
    IUIAutomationPatternInstance * _pInstance;

public:
    // Get IUIAutomationPatternInstance interface pointer.
    CMyValuePatternClientWrapper(IUIAutomationPatternInstance * pInstance)
    {
        _pInstance = pInstance;
        _pInstance->AddRef();
    }

    // Put standard IUnknown implementation here.

    STDMETHODIMP get_CurrentValue(BSTR * pValue)
    {
        return _pInstance->GetProperty(MyValue_GetValue, FALSE, 
                UIAutomationType_String, pValue);
    }

    STDMETHODIMP get_CachedValue(BSTR * pValue)
    {
        return _pInstance->GetProperty(MyValue_GetValue, TRUE, 
                UIAutomationType_String, pValue);
    }

    STDMETHODIMP get_CurrentIsReadOnly(BOOL * pIsReadOnly)
    {
        return _pInstance->GetProperty(MyValue_GetIsReadOnly, FALSE, 
                UIAutomationType_Bool, pIsReadOnly);
    }

    STDMETHODIMP get_CachedIsReadOnly(BOOL * pIsReadOnly)
    {
        return _pInstance->GetProperty(MyValue_GetIsReadOnly, TRUE, 
                UIAutomationType_Bool, pIsReadOnly);
    }

    STDMETHODIMP SetValue(LPCWSTR pValue)
    {
        UIAutomationParameter SetValueParams[] = 
                { UIAutomationType_String, &pValue };
        return _pInstance->CallMethod(MyValue_SetValue,  SetValueParams, 
                ARRAYSIZE(SetValueParams));
    }

    STDMETHODIMP Reset()
    {
        return _pInstance->CallMethod(MyValue_Reset, NULL, 0);
    }
};

// Step 3: Implement the pattern handler class.
class CMyValuePatternHandler : public IUIAutomationPatternHandler
{
public:

    // Put standard IUnknown implementation here.
    
    STDMETHODIMP CreateClientWrapper(
            IUIAutomationPatternInstance * pPatternInstance, 
            IUnknown ** pClientWrapper)
    {
        *pClientWrapper = new CMyValuePatternClientWrapper(pPatternInstance);
        if (*pClientWrapper == NULL)
            return E_INVALIDARG;
        return S_OK;
    }
    
    STDMETHODIMP Dispatch (IUnknown * pTarget, UINT index, 
            const struct UIAutomationParameter *pParams, 
            UINT cParams)
    {
        switch(index)
        {
        case MyValue_GetValue:
            return ((IMyValueProvider*)pTarget)->get_Value((BSTR*)pParams[0].pData);

        case MyValue_GetIsReadOnly:
            return ((IMyValueProvider*)pTarget)->get_IsReadOnly((BOOL*)pParams[0].pData);

        case MyValue_SetValue:
            return ((IMyValueProvider*)pTarget)->SetValue(*(LPCWSTR*)pParams[0].pData);

        case MyValue_Reset:
            return ((IMyValueProvider*)pTarget)->Reset();
        }
        return E_INVALIDARG;
    }
};

CMyValuePatternHandler g_MyValuePatternHandler;

// Step 4: Declare information about the properties and methods supported
// by the custom control pattern.

// Define GUIDs for the custom control pattern and each of its properties 
// and events.
static const GUID MyValue_Pattern_Guid = { 0xa49aa3c0, 0xe413, 0x4ecf, 
        { 0xa1, 0xc3, 0x37, 0x42, 0xa7, 0x86, 0x67, 0x3f } };
static const GUID MyValue_Value_Property_Guid = { 0xe58f3f67, 0x22c7, 0x44f0, 
        { 0x83, 0x55, 0xd8, 0x76, 0x14, 0xa1, 0x10, 0x81 } };
static const GUID MyValue_IsReadOnly_Property_Guid = { 0x480540f2, 0x9829, 0x4acd, 
        { 0xb8, 0xea, 0x6e, 0x2a, 0xdc, 0xe5, 0x3a, 0xfb } };
static const GUID MyValue_Reset_Event_Guid = { 0x5b80edd3, 0x67f, 0x4a70, 
        { 0xb0, 0x7, 0x4, 0x12, 0x85, 0x11, 0x1, 0x7a } };

// Declare information about the properties, in the same order as the
// previously defined "MyValue_" enumerated type.
UIAutomationPropertyInfo g_MyValueProperties[] = 
{
    // GUID, name, data type.
    { MyValue_Value_Property_Guid, L"MyValuePattern.Value", 
                                                    UIAutomationType_String },
    { MyValue_IsReadOnly_Property_Guid, L"MyValuePattern.IsReadOnly", 
                                                    UIAutomationType_Bool },
};

// Declare information about the event.
UIAutomationEventInfo g_MyValueEvents [] =
{
    { MyValue_Reset_Event_Guid,  L"MyValuePattern.Reset" },
};

// Declare the data type and name of the SetValue method parameter. 
UIAutomationType g_SetValueParamTypes[] = { UIAutomationType_String };
LPCWSTR g_SetValueParamNames[] = {L"pNewValue"};

// Declare information about the methods.
UIAutomationMethodInfo g_MyValueMethods[] =
{
    // Name, focus flag, count of in parameters, count of out parameters, types, parameter names.
    { L"MyValuePattern.SetValue", TRUE, 1, 0, g_SetValueParamTypes, g_SetValueParamNames },
    { L"MyValuePattern.Reset", TRUE, 0, 0, NULL, NULL },
};

// Declare the custom control pattern using the previously defined information.
UIAutomationPatternInfo g_ValuePatternInfo =
{
    MyValue_Pattern_Guid,
    L"MyValuePattern",
    __uuidof(IMyValueProvider),
    __uuidof(IUIAutomationMyValuePattern),
    ARRAYSIZE(g_MyValueProperties), g_MyValueProperties, // properties
    ARRAYSIZE(g_MyValueMethods), g_MyValueMethods,       // methods
    ARRAYSIZE(g_MyValueEvents), g_MyValueEvents,         // events 
    &g_MyValuePatternHandler
};

// Step 5: Register the custom control pattern and retrieve the control pattern and property 
// identifiers.

// Control pattern, property, and event IDs.
PATTERNID  g_MyValue_PatternID;
PROPERTYID g_MyValue_Value_PropertyID;
PROPERTYID g_MyValue_IsReadOnly_PropertyID;
EVENTID    g_MyValueReset_EventID;

// ID used by the client to determine whether the custom control pattern is available.
PROPERTYID g_IsMyValuePatternAvailable_PropertyID;

HRESULT RegisterPattern()
{
    // Create the registrar object and get the IUIAutomationRegistrar interface pointer. 
    IUIAutomationRegistrar * pUIARegistrar;
    CoCreateInstance(CLSID_CUIAutomationRegistrar, NULL, CLSCTX_INPROC_SERVER, 
            IID_IUIAutomationRegistrar, (void **)&pUIARegistrar);

    if (pUIARegistrar == NULL)
        return E_NOINTERFACE;

    PROPERTYID propIDs[2]; // Array for property IDs.

    // Register the control pattern.
    HRESULT hr = pUIARegistrar->RegisterPattern(
        &g_ValuePatternInfo,
        &g_MyValue_PatternID,
        &g_IsMyValuePatternAvailable_PropertyID,
        ARRAYSIZE(propIDs), 
        propIDs,
        1,
        &g_MyValueReset_EventID);
            
    if (hr == S_OK)
    {
        // Copy the property IDs.
        g_MyValue_Value_PropertyID = propIDs[0];
        g_MyValue_IsReadOnly_PropertyID = propIDs[1];
    }

    pUIARegistrar->Release();
    return hr;
}

Související témata

koncepční

navrhování vlastních vlastností, událostí a vzorů ovládacích prvků

Přehled vlastností automatizace uživatelského rozhraní

Přehled událostí automatizace uživatelského rozhraní

Přehled vzorů ovládacích prvků automatizace uživatelského rozhraní