Como criar uma etiqueta inteligente DLL no ATL para utilizar no Office XP

Traduções de Artigos Traduções de Artigos
Artigo: 292596 - Ver produtos para os quais este artigo se aplica.
Este artigo foi arquivado. Este artigo é oferecido "tal como está" e deixará de ser actualizado.
Expandir tudo | Reduzir tudo

Nesta página

Sumário

As etiquetas inteligentes são uma tecnologia introduzida com o Office XP que fornecer utilizadores do Office mais interactividade com o conteúdo dos respectivos documentos do Office. Uma etiqueta inteligente é um elemento do texto num documento do Office que é reconhecido como tendo acções personalizadas a ele associado. Um exemplo de um destes elementos especiais de texto poderá ser um nome de correio electrónico que é escrito num documento do Word ou um livro do Excel. Se o nome de correio electrónico for reconhecido como uma etiqueta inteligente, o utilizador é apresentado com uma ou mais acções para executar nesse texto. Acções possíveis que estão associadas a um nome de correio electrónico são para procurar informações de contacto adicionais ou para enviar uma mensagem de correio electrónico nova com esse contacto.

Pode expandir as capacidades do Office XP a desenvolver a suas próprias Biblioteca de ligação dinâmica Smart Tags Recognizer / Action (DLL, dynamic-link library) para utilização em documentos do Office. Este artigo descreve como criar uma DLL etiquetas inteligentes, utilizando Active modelo Biblioteca (ATL), e explica as definições de registo são necessários para o Office XP para identificar e utilizar as DLL etiqueta inteligente.

NOTA : Excel 2002 e Word 2002 são as aplicações do Office XP só que suportem etiquetas inteligentes. No entanto, as informações que são apresentadas contidas neste artigo podem ser aplicadas para o desenvolvimento de etiquetas inteligentes para qualquer aplicação que adopta a tecnologia de etiquetas inteligentes. Uma DLL etiqueta inteligente é um padrão DLL que implementa duas interfaces especiais componente (COM object model): a ISmartTagRecognizer e a ISmartTagAction . A interface a ISmartTagRecognizer reconhece o texto que é escrito num documento como uma etiqueta inteligente. A interface a ISmartTagAction efectua acções numa cadeia de etiquetas inteligentes específica a pedido do utilizador. Não for necessário que estas interfaces ser implementado na mesma DLL. Pode ter um reconhecedor DLL, e de seguida, acção um ou mais DLL que expandem um único tipo de etiquetas inteligentes para acções diferentes.




Passos para criar a etiqueta inteligente DLL no ATL


Os passos que se seguem Criar simples inteligentes uma DLL de tags que reconhece os contactos do Microsoft Network (MSN) Instant Messenger e oferece o utilizador a capacidade de enviar correio electrónico ou mensagens instantâneas para um contacto reconhecido. Messenger instantânea é necessária para utilizar este exemplo. Se ainda não tiver o Instant Messenger, pode obter uma cópia a partir do seguinte site Web da MSN:
http://messenger.msn.com/

  1. No Visual C++, criar um novo projecto ATL AppWizard com. Nome do Projecto MessengerSmartTag.
  2. Clique em OK para iniciar o assistente com ATL. Na caixa de diálogo seguinte, certifique-se de que Biblioteca de ligação dinâmica está seleccionada e clique em Concluir . Clique em OK para criar o projecto.
  3. Para criar a classe reconhecedor , no menu Inserir , clique em Novo objecto ATL . Seleccione Simple Object e faça clique sobre seguinte . Para o nome abreviado, escreva Recognizer e clique em OK .
  4. Para criar a classe de acção , siga as instruções no passo 3, mas escreva acção para o nome abreviado.
  5. Abra o ClassView e expanda MessengerSmartTag classes . Clique com o botão direito do rato a classe CRecognizer e seleccione interface implementar . Clique sobre ' OK ' quando é apresentada a caixa de diálogo de aviso. Faça clique sobre Procurar e seleccione Microsoft Smart Tags 1.0 Type Library . Seleccione o a ISmartTagRecognizer e a interface ISmartTagRecognizer2 e prima ' OK '.

    NOTA : A localização predefinida para o Microsoft Smart Tags 1.0 Type Library é C:\Program Files\Common Files\Microsoft Shared\Mstag.tlb.
  6. Na ClassView, clique com o botão direito do rato na classe CAction e seleccione interface implementar . Clique sobre ' OK ' quando é apresentada a caixa de diálogo de aviso. Faça clique sobre Procurar e seleccione Microsoft Smart Tags 1.0 Type Library . Seleccione o a ISmartTagAction e a interface ISmartTagAction2 e clique em OK .
  7. Abra o ficheiro Recognizer.h e substituir o conteúdo de classe com o seguinte código:
    ///////////////////////////////////////////////////////////////////////////// 
    // CRecognizer
    #include "Resource.h"
    #import "C:\Program Files\Common Files\Microsoft Shared\Smart Tag\MSTAG.TLB" raw_interfaces_only, raw_native_types, no_namespace, named_guids 
    class ATL_NO_VTABLE CRecognizer : 
       public CComObjectRootEx<CComSingleThreadModel>,
       public CComCoClass<CRecognizer, &CLSID_Recognizer>,
       public IDispatchImpl<IRecognizer, &IID_IRecognizer, &LIBID_MESSENGERSMARTTAGLib>,
       public IDispatchImpl<ISmartTagRecognizer, &IID_ISmartTagRecognizer, &LIBID_SmartTagLib>,
       public IDispatchImpl<ISmartTagRecognizer2, &IID_ISmartTagRecognizer2, &LIBID_SmartTagLib>
    {
    public:
    
        CRecognizer();
        ~CRecognizer();
    
    DECLARE_REGISTRY_RESOURCEID(IDR_RECOGNIZER)
    
    DECLARE_PROTECT_FINAL_CONSTRUCT()
    
    BEGIN_COM_MAP(CRecognizer)
        COM_INTERFACE_ENTRY(IRecognizer)
    //Removed -- COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY2(IDispatch, IRecognizer)
        COM_INTERFACE_ENTRY(ISmartTagRecognizer)
        COM_INTERFACE_ENTRY(ISmartTagRecognizer2)
    END_COM_MAP()
    
    // IRecognizer
    public:
    // ISmartTagRecognizer
        STDMETHOD(get_ProgId)(BSTR * ProgId);
        STDMETHOD(get_Name)(INT LocaleID, BSTR * Name);
        STDMETHOD(get_Desc)(INT LocaleID, BSTR * Desc);
        STDMETHOD(get_SmartTagCount)(INT * Count);
        STDMETHOD(get_SmartTagName)(INT SmartTagID, BSTR * Name);
        STDMETHOD(get_SmartTagDownloadURL)(INT SmartTagID, BSTR * DownloadURL);
        STDMETHOD(Recognize)(BSTR Text, IF_TYPE DataType, INT LocaleID,
                      ISmartTagRecognizerSite * RecognizerSite);
    private:
        long lCount;
        SAFEARRAY *psa;
    // ISmartTagRecognizer2
        STDMETHOD(Recognize2)(BSTR Text, IF_TYPE DataType, INT LocaleID, ISmartTagRecognizerSite2 * RecognizerSite2, BSTR ApplicationName, ISmartTagTokenList * TokenList)
        {
            return E_NOTIMPL;
        }
        STDMETHOD(get_PropertyPage)(INT SmartTagID, INT LocaleID, VARIANT_BOOL * HasPropPage)
        {
            if (HasPropPage == NULL)
                return E_POINTER;
    		    
            return E_NOTIMPL;
        }
        STDMETHOD(DisplayPropertyPage)(INT SmartTagID, INT LocaleID)
        {
            return E_NOTIMPL;
        }
        STDMETHOD(SmartTagInitialize)(BSTR ApplicationName)
        {
            return E_NOTIMPL;
        }
    };
    					
  8. Abra o ficheiro Recognizer.cpp e adicione o seguinte código ao fim do ficheiro:
    CRecognizer::CRecognizer()
    {
        Messenger::IMsgrObject2Ptr oMsgrObj = NULL;
        Messenger::IMsgrUsersPtr oUsers = NULL;
        Messenger::IMsgrUserPtr oUser = NULL;
        SAFEARRAYBOUND rgsaBound[1];
        long rgIndices[1];		
        HRESULT hr;
    		
        // Create an instance of Instant Messenger.
        oMsgrObj.CreateInstance("Messenger.MsgrObject");
        // Get the list of contacts
        oUsers = oMsgrObj->GetList(Messenger::MLIST_CONTACT);
        // Store the number of contacts you have.
        lCount = oUsers->GetCount();
        rgsaBound[0].lLbound = 0;
        rgsaBound[0].cElements = lCount;
        // Create a SAFEARRAY to hold the list of contacts.
        psa = SafeArrayCreate(VT_VARIANT, 1, rgsaBound);
        // Loop through all contacts.
        for (long l=0; l<lCount-1; l++)
        {
            rgIndices[0] = l;	
            // Set the specific user.
            oUser = oUsers->Item(l);
            // Convert the Friendly Name to lower case
            // and store it in a VARIANT.
            _variant_t v = _wcslwr(oUser->GetFriendlyName());
            // Put the VARIANT into the SAFEARRAY.
           hr = SafeArrayPutElement(psa, rgIndices, &v);
        }
    }
    
    CRecognizer::~CRecognizer()
    {
        // Destroy the SAFEARRAY.
        SafeArrayDestroy(psa);
    }
    
    
    HRESULT CRecognizer::get_ProgId(BSTR * ProgId)
    {
        // Set the ProgID of the Recognizer interface.
        *ProgId = SysAllocString(L"MessengerSmartTag.Recognizer");
        return S_OK;
    }
    
    HRESULT CRecognizer::get_Name(INT LocaleID, BSTR * Name)
    {
        // Set a short title about the recognizer.
        *Name = SysAllocString(L"Microsoft Messenger Contacts Visual C++ Recognizer");
        return S_OK;
    }
    
    HRESULT CRecognizer::get_Desc(INT LocaleID, BSTR * Desc)
    {
        // Set a long description of the recognizer.
        *Desc = SysAllocString(L"Microsoft Messenger recognizes your Instant Messenger Contacts");
        return S_OK;
    }
    
    HRESULT CRecognizer::get_SmartTagCount(INT * Count)
    {
        // Set the number of Smart Tags that are supported.
        *Count = 1;
        return S_OK;
    }
    
    HRESULT CRecognizer::get_SmartTagName(INT SmartTagID, BSTR * Name)
    {
        // This method is called the same number of times as you
        // return in SmartTagCount. This method sets a unique name
        // for the Smart Tag.
        *Name = SysAllocString(L"microsoft/messenger#contacts");
        return S_OK;
    }
    
    HRESULT CRecognizer::get_SmartTagDownloadURL(INT SmartTagID, BSTR * DownloadURL)
    {
        // Set the URL that gets embedded in documents.
        *DownloadURL = NULL;
        return S_OK;
    }
    
    HRESULT CRecognizer::Recognize(BSTR Text, IF_TYPE DataType, INT LocaleID,
           ISmartTagRecognizerSite * RecognizerSite)
    {
        // The Recognize method is called and passed a text value.
        // You should recognize strings in the text and set up the actions.
        WCHAR *pch, *strText = _wcslwr(Text);
        ISmartTagProperties  *pSmartTagProp = NULL;
        long rgIndices[1];
        HRESULT hr;
    
        // Look through all contacts
        for (long l = 0; l<lCount; l++)
        {
            rgIndices[0] = l;
    
            // Get the contact name.
            _variant_t v;
            hr = SafeArrayGetElement(psa,rgIndices,&v);
            // Convert the VARIANT to a BSTR.
            _bstr_t bstrContact = v;
            // Loop through the string looking for contacts.
            for (pch = strText; (pch = wcsstr(pch, bstrContact))!=NULL; pch++)
            {    
                // Create a new property bag.
                hr = RecognizerSite->GetNewPropertyBag(&pSmartTagProp);
                if (SUCCEEDED(hr)) {
                    // Commit the Smart Tag to the property bag.		                
                    hr = RecognizerSite->CommitSmartTag(
                          _bstr_t("microsoft/messenger#contacts"),
                          pch - strText+1, wcslen(bstrContact),
                          pSmartTagProp);
                    
                    if (pSmartTagProp != NULL)
                        pSmartTagProp->Release();
                }
            }
        }
        return S_OK;
    }
    					
  9. Abra o ficheiro Action.h e substituir o conteúdo da classe com o seguinte código:
    ///////////////////////////////////////////////////////////////////////////// 
    // CAction
    #include "Resource.h"
    #import "C:\Program Files\Common Files\Microsoft Shared\Smart Tag\MSTAG.TLB" raw_interfaces_only, raw_native_types, no_namespace, named_guids 
    class ATL_NO_VTABLE CAction : 
       public CComObjectRootEx<CComSingleThreadModel>,
       public CComCoClass<CAction, &CLSID_Action>,
       public IDispatchImpl<IAction, &IID_IAction, &LIBID_MESSENGERSMARTTAGLib>,
       public IDispatchImpl<ISmartTagAction, &IID_ISmartTagAction, &LIBID_SmartTagLib>,
       public IDispatchImpl<ISmartTagAction2, &IID_ISmartTagAction2, &LIBID_SmartTagLib>
    {
    public:
       CAction(){}
    
    DECLARE_REGISTRY_RESOURCEID(IDR_ACTION)
    
    DECLARE_PROTECT_FINAL_CONSTRUCT()
    
    BEGIN_COM_MAP(CAction)
        COM_INTERFACE_ENTRY(IAction)
    //Removed -- COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY2(IDispatch, IAction)
        COM_INTERFACE_ENTRY(ISmartTagAction)
        COM_INTERFACE_ENTRY(ISmartTagAction2)
    END_COM_MAP()
    
    // IAction
    public:
    // ISmartTagAction
        STDMETHOD(get_ProgId)(BSTR * ProgId);
        STDMETHOD(get_Name)(INT LocaleID, BSTR * Name);
        STDMETHOD(get_Desc)(INT LocaleID, BSTR * Desc);
        STDMETHOD(get_SmartTagCount)(INT * Count);
        STDMETHOD(get_SmartTagName)(INT SmartTagID, BSTR * Name);
        STDMETHOD(get_SmartTagCaption)(INT SmartTagID, INT LocaleID,
                      BSTR * Caption);
        STDMETHOD(get_VerbCount)(BSTR SmartTagName, INT * Count);
        STDMETHOD(get_VerbID)(BSTR SmartTagName, INT VerbIndex, INT * VerbID);
        STDMETHOD(get_VerbCaptionFromID)(INT VerbID, BSTR ApplicationName,
                      INT LocaleID, BSTR * Caption);
        STDMETHOD(get_VerbNameFromID)(INT VerbID, BSTR * Name);
        STDMETHOD(InvokeVerb)(INT VerbID, BSTR ApplicationName,
                      IDispatch * Target, ISmartTagProperties * Properties,
                      BSTR Text, BSTR Xml);
    // ISmartTagAction2
        STDMETHOD(get_VerbCaptionFromID2)(INT VerbID, BSTR ApplicationName, INT LocaleID, ISmartTagProperties * Properties, BSTR Text, BSTR Xml, IDispatch * Target, BSTR * Caption)
        {
            if (Caption == NULL)
                return E_POINTER;
    
            return E_NOTIMPL;
        }
        STDMETHOD(InvokeVerb2)(INT VerbID, BSTR ApplicationName, IDispatch * Target, ISmartTagProperties * Properties, BSTR Text, BSTR Xml, INT LocaleID)
        {
            return E_NOTIMPL;
        }
        STDMETHOD(get_IsCaptionDynamic)(INT VerbID, BSTR ApplicationName, INT LocaleID, VARIANT_BOOL * Dynamic)
        {
            if (Dynamic == NULL)
                return E_POINTER;
    
            return E_NOTIMPL;
        }
        STDMETHOD(get_ShowSmartTagIndicator)(INT VerbID, BSTR ApplicationName, INT LocaleID, VARIANT_BOOL * Visible)
        {
            if (Visible == NULL)
                return E_POINTER;
    
            return E_NOTIMPL;
        }
        STDMETHOD(SmartTagInitialize)(BSTR ApplicationName)
        {
            return E_NOTIMPL;
        }
    };
    					
  10. Abra o ficheiro Action.cpp e adicionar o seguinte código ao final do ficheiro:
    HRESULT CAction::get_ProgId(BSTR * ProgId)
    {
       // Set the ProgID of the Action interface.
       *ProgId = SysAllocString(L"MessengerSmartTag.Action");
       return S_OK;
    }
    
    HRESULT CAction::get_Name(INT LocaleID, BSTR * Name)
    {
       // Set a short name describing the Action.
       *Name = SysAllocString(L"Messenger Smart Tag");
       return S_OK;
    }
    
    HRESULT CAction::get_Desc(INT LocaleID, BSTR * Desc)
    {
       // Set a long description describing the action.
       *Desc = SysAllocString(L"Provides actions for the Messenger Smart Tag");
       return S_OK;
    }
    
    HRESULT CAction::get_SmartTagCount(INT * Count)
    {
        // Set the number of smart tags this action supports.
        *Count = 1;
        return S_OK;
    }
    
    HRESULT CAction::get_SmartTagName(INT SmartTagID, BSTR * Name)
    {
        // This method is called the same number of times as you
        // return in SmartTagCount. This method sets a unique name
        // for the smart tag.
        *Name = SysAllocString(L"microsoft/messenger#contacts");
        return S_OK;
    }
    
    HRESULT CAction::get_SmartTagCaption(INT SmartTagID, INT LocaleID, BSTR * Caption)
    {
        // This caption is displayed on the menu for the smart tag.
        *Caption = SysAllocString(L"Messenger Smart Tag");
        return S_OK;
    }
    
    HRESULT CAction::get_VerbCount(BSTR SmartTagName, INT * Count)
    {
        // Return the number of verbs we support.
        if (wcsstr(SmartTagName,L"microsoft/messenger#contacts") != 0) {
            *Count = 2;
        }
        return S_OK;
    }
    
    HRESULT CAction::get_VerbID(BSTR SmartTagName, INT VerbIndex, INT * VerbID)
    {
        // Return a unique ID for each verb we support.
        *VerbID = VerbIndex;
        return S_OK;
    }
    
    HRESULT CAction::get_VerbCaptionFromID(INT VerbID, BSTR ApplicationName,
                         INT LocaleID, BSTR * Caption)
    {
        // Set a caption for each verb. This caption is displayed
        // on the Smart Tag menu.
        switch (VerbID) {
          case 1:
            *Caption = SysAllocString(L"Send this contact an Instant Message");
            break;
          case 2:
            *Caption = SysAllocString(L"Send email to this contact");
            break;
          default:
            *Caption = NULL;
            break;
        }
        return S_OK;
    }
    
    HRESULT CAction::get_VerbNameFromID(INT VerbID, BSTR * Name)
    {
        // Set a string name for each verb.
        switch (VerbID) {
          case 1:
            *Name = SysAllocString(L"SendInstantMessage");
            break;
          case 2:
            *Name = SysAllocString(L"SendEmail");
            break;
        }
        return S_OK;
    }
    HRESULT CAction::InvokeVerb(INT VerbID, BSTR ApplicationName,
          IDispatch * Target, ISmartTagProperties * Properties,
          BSTR Text, BSTR Xml)
    {
        // This method is called when a user invokes a verb
        // from the Smart Tag menu.
        Messenger::IMessengerApp2Ptr oMessenger = NULL;
        Messenger::IMsgrObject2Ptr oMsgrObj = NULL;
        Messenger::IMsgrUsersPtr oUsers = NULL;
        Messenger::IMsgrUserPtr oUser = NULL;
        _variant_t v;		
    
        // Create an instance of Instant Messenger.
        oMessenger.CreateInstance("Messenger.MessengerApp");
        oMsgrObj.CreateInstance("Messenger.MsgrObject");
        // Get a list of contacts.
        oUsers = oMsgrObj->GetList(Messenger::MLIST_CONTACT);
        // Loop through all contacts.
        for (long l=0; l<(oUsers->GetCount()-1); l++)
        {
            // Get a specific contact.
            oUser = oUsers->Item(l);
            // Check to see if the contact is the correct one.
    	if (wcscmp(_wcslwr(oUser->GetFriendlyName()),_wcslwr(Text)) == 0)
            {
                switch (VerbID) {
                  case 1:
                    // The user wants to display the Instant Message
                    // box to send the contact a message.
                    v = oUser.GetInterfacePtr();					
                    oMessenger->LaunchIMUI(v);
                    break;
                  case 2:
                    // Shell the "mailto" protocol to start the
                    // user's mail program and create a new message.
                    _bstr_t bstrTemp = "mailto:";
                    bstrTemp += oUser->GetEmailAddress();				                
                    ShellExecute(0,"open",bstrTemp,NULL,NULL,1);
                    break;
                }
            }
        }
        return S_OK;
    }
    					
  11. Abra o ficheiro Stdafx.h e adicione a seguinte linha a seguir à linha que lê # incluir <atlcom.h>:
    #import "C:\Program Files\Messenger\msmsgs.exe"
    						
    NOTA : Alterar o caminho do ficheiro Msmsgs.exe até ao ponto de instalação para o Instant Messenger. A localização predefinida para o Instant Messenger é C:\Program Files\Messenger.
  12. Prima F7 para criar a DLL.




Passos para registar a etiqueta inteligente DLL



Antes de poder utilizar qualquer DLL etiqueta inteligente, tem de registá-lo no sistema. Registo normal com é efectuado automaticamente quando compilar o projecto ou chamar o ficheiro Regsvr32.exe com o nome da DLL. É necessário criar entradas de registo adicionais que não fazem parte do registo COM normal para que possa identificar as aplicações do Office a DLL como uma DLL etiquetas inteligentes. Para efectuar este procedimento, siga estes passos.:
  1. A partir de uma linha de comandos, inicie o Regedit.exe.
  2. No Tag\Actions HKEY_CURRENT_USER\Software\Microsoft\Office\Common\Smart , adicione uma nova subchave com o nome MessengerSmartTag.Action.
  3. No Tag\Recognizers HKEY_CURRENT_USER\Software\Microsoft\Office\Common\Smart , adicione uma nova subchave com o nome MessengerSmartTag.Recognize.
  4. Feche o Editor de registo..




Passos para testar a etiqueta inteligente DLL



As etiquetas inteligentes obedecer o mesmo modelo de segurança como macros. Se as definições de segurança da aplicação estão definidas como Alta, a DLL etiquetas inteligentes não carregará a menos que a DLL está assinado digitalmente (como acontece também com macros VBA). Para obter mais informações sobre a assinatura digital, consulte a secção " Referências ".

Para testar personalizado Smart Tags a dll Recognizer / action no Word, siga estes passos:
  1. Inicie o Instant Messenger e inicie sessão no.

    NOTA : O exemplo etiqueta inteligente requer que inicia sessão com o Instant Messenger; se não iniciar sessão com o Instant Messenger, a DLL personalizada carrega mas não reconhece todos os contactos.
  2. Inicie o Word 2002. No menu Ferramentas , aponte para Macro e clique em Segurança . Defina a segurança de macros como Média e clique em OK . Se a definição de segurança de macros estiver definida como Máximo-Mínimo , anteriormente reinicie o Word.
  3. Escreva o nome amigável de um contacto num novo documento (por exemplo, João Silva) e prima ENTER. Uma linha de impressão muito ténues aparece por baixo o nome amigável para indicar que é reconhecido como uma etiqueta inteligente. Mova o rato sobre o nome amigável, e o botão Acções etiquetas inteligentes aparece.
  4. Clique em Acção Etiqueta Inteligente e seleccione um dos itens de acção personalizada a partir do menu pendente. Pode enviar um correio electrónico ou mensagem instantânea para o contacto do novo documento.
Pode utilizar passos semelhantes para testar a dll etiquetas inteligentes no Excel 2002.





A resolução de problemas



Se tiver problemas ao obter as Etiquetas Inteligentes Personalizadas no seu trabalho, certifique-se a DLL smart tags personalizadas que está a ser carregada. Na Word ou Excel, no menu Ferramentas , faça clique sobre Opções Correcção Automática , faça clique sobre o separador de etiquetas inteligentes e certifique-se de que as DLL Etiqueta Inteligente é listado e seleccionado e etiqueta de texto com etiquetas inteligentes que está seleccionada. Lo se a etiqueta inteligente não estiver listada, pode não estar correctamente registado.

Que se a execução da classe reconhecedor ou acção personalizada for a origem do problema, pode depurar uma DLL etiquetas inteligentes como faria qualquer DLL Visual C++. Definir um ponto de interrupção no construtor para a classe Recognizer. Quando premir F5 para depurar a aplicação, uma caixa de diálogo aparece e pede um ficheiro executável para a sessão de depuração. Seleccionar Winword.exe ou Excel.exe . Quando o Excel ou para o Word é iniciado e carrega a etiqueta inteligente, o código quebras no ponto de interrupção e que pode avança o código para a depuração.



REFERENCES


Documentação para estas interfaces, juntamente com a biblioteca de tipos necessários que define-los, é fornecida Smart Tags software Kit no (SDK) de desenvolvimento. Se ainda não tiver feito, deverá instalar o Smart Tag SDK antes de prosseguir com os passos para criar o exemplo de etiquetas inteligentes. É possível obter o Smart Tag SDK a partir o XP Microsoft Office Developer (MOD) de CD-ROM, ou que pode transferi-lo a partir do seguinte Web site Microsoft Developer Network (MSDN):
Software Development Kit da etiqueta inteligente
http://www.microsoft.com/downloads/details.aspx?familyid=3d8edcee-0246-43ef-a70f-94c0899f1e8f&displaylang=en



Para mais informações sobre como criar personalizado Smart Tags Recognizer / action DLLs, consulte o ficheiro Smart Tags ajuda de programação que se encontra incluído Smart Tag SDK.

Para obter informações adicionais sobre assinaturas digitais, clique no número de artigo abaixo para visualizar o artigo na Microsoft Knowledge Base:
247257 INFO: Os passos para assinar um ficheiro.cab
Para obter informações sobre como utilizar CLSIDs para registar a DLL Smart Tags em vez de ProgID, consulte o seguinte artigo na Microsoft Knowledge Base:
294422 SINALIZADOR DE ESTADO BUG: NÃO É actualizada quando activar ou desactivar etiquetas inteligentes




Propriedades

Artigo: 292596 - Última revisão: 24 de fevereiro de 2014 - Revisão: 10.1
A informação contida neste artigo aplica-se a:
  • Microsoft Excel 2002 Standard Edition
  • Microsoft Word 2002 Standard Edition
  • Microsoft Visual C++ 6.0 Professional Edition
Palavras-chave: 
kbnosurvey kbarchive kbhowto kbhowtomaster KB292596 KbMtpt kbmt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Pedíamos-lhe o favor de preencher o formulário existente no fundo desta página caso tenha encontrado erros neste artigo e tenha possibilidade de colaborar no processo de aperfeiçoamento desta ferramenta. Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 292596

Submeter comentários

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com