Office XP - Crie uma DLL de Marca Inteligente em ATL para utilização no Office XP

Traduções deste artigo Traduções deste artigo
ID do artigo: 292596 - Exibir os produtos aos quais esse artigo se aplica.
Este artigo foi publicado anteriormente em BR292596
Este artigo foi arquivado. É oferecido "como está" e não será mais atualizado.
Expandir tudo | Recolher tudo

Sumário

NESTA TAREFA
? ?Passos para criar a DLL de Marca Inteligente em ATL
?Passos para registrar a DLL de Marca Inteligente
?Passos para testar a DLL de Marca Inteligente
?Solução de problemas
?REFERÊNCIAS

RESUMO
Marcas inteligentes são uma tecnologia introduzida com o
Office XP que fornece aos usuários do Office mais
interatividade com o conteúdo de seus documentos do Office.
Uma Marca Inteligente é um elemento de texto em um
documento do Office que é reconhecido como tendo ações
personalizadas associadas com ele. Um exemplo de um desses
elementos especiais de texto poderia ser um nome de correio
eletrônico que é digitado em um documento do Word ou uma
pasta de trabalho Excel. Se o nome de correio eletrônico
for reconhecido como uma Marca Inteligente, o usuário tem
uma ou mais ações para realizar sobre esse texto. Possíveis
ações associadas com um nome de correio eletrônico são
pesquisar informações adicionais sobre o contato, ou enviar
uma nova mensagem de correio eletrônico para esse contato.
Você pode estender as capacidades do Office XP
desenvolvendo sua DLL (dynamic-link library) Reconhecedora
de Marca Inteligente/Ação para utilização em documentos do
Office. Este artigo descreve como construir uma DLL de
Marca Inteligente utilizando Active Template Library (ATL)
e discute as configurações de registro necessárias para o
Office XP identificar e utilizar sua DLL de Marca
Inteligente.
OBSERVAÇÃO: O Excel 2002 e o Word 2002 são os únicos
aplicativos do Office XP que suportam Marcas
Inteligentes. Entretanto, as informações apresentadas
neste artigo podem ser aplicadas para desenvolvimento de
Marca Inteligente para qualquer aplicativo que adote a
tecnologia de Marca Inteligente. Uma DLL de Marca
Inteligente é um DLL do Component Object Model (COM)
padrão que implementa duas interfaces especiais:
ISmartTagRecognizer e ISmartTagAction. A interface de
ISmartTagRecognizer reconhece texto que é digitado em um
documento como uma Marca Inteligente. A interface de
ISmartTagAction realiza ações em uma string particular
de Marca Inteligente na solicitação do usuário. Não é
requerido que essas interfaces sejam implementadas na
mesma DLL. Você pode ter uma DLL reconhecedora, e então
uma ou mais DLLs de ação que estendem um único tipo de
Marca Inteligente para diferentes ações.

Passos para criar a DLL de Marca Inteligente em ATL
Os seguintes passos criam uma DLL de Marca Inteligente que
reconhece The Microsoft Network (MSN) contatos do Instant
Messenger e permite ao usuário enviar correio eletrônico ou
mensagens instantâneas para um contato reconhecido. O
Instant Messenger é requerido utilizar este exemplo. Se
você não tiver o Instant Messenger, você pode obter uma
cópia do seguinte site da Web de MSN:
http://messenger.msn.com/
1.Em Visual C++, crie um novo projeto ATL COM AppWizard.
Nomeie o projeto como MessengerSmartTag.
2.Clique em OK para iniciar o assistente de ATL COM. Na
próxima caixa de diálogo, certifique-se de que Dynamic
Link Library está selecionada e clique em Finish. Clique
em OK para criar o projeto.
3.Criar a classe Recognizer, no menu Insert, clique em New
ATL Object. Selecione Objeto Simples e clique em
Avançar. Para o nome curto, digite Recognizer e clique
em OK.
4.Para criar a classe Action, siga as instruções no passo
3, mas digite Action para o nome curto.
5.Abra o ClassView e expanda as classes MessengerSmartTag.
Clique com o botão direito do mouse na classe
CRecognizer e selecione Implement Interface. Clique em
OK quando a caixa de diálogo de advertência aparecer.
Clique em Navega e selecione Microsoft Smart Tags 1.0
Type Library. Selecione a interface de
ISmartTagRecognizer e pressione OK.
OBSERVAÇÃO: A localização padrão para as Microsoft
Smart Tags 1.0 Type Library é C:\Arquivos de
Programas\Common Files\Microsoft Shared\Mstag.tlb.
6.Em ClassView, clique com o botão direito do mouse na
classe de CAction e selecione Implement Interface.
Clique em OK quando a caixa de diálogo de advertência
aparecer. Clique em Navega e selecione Microsoft Smart
Tags 1.0 Type Library. Selecione a interface de
ISmartTagAction e clique em OK.
7.Abra o arquivo de Recognizer.h e substitua o conteúdo de
classe com o seguinte código:
////////////////////////////////////////////////////////
/////////////////////
// CRecognizer
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:

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)
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;
};
8.Abra o arquivo de Recognizer.cpp e adicione o seguinte
código à extensão do arquivo:
CRecognizer::CRecognizer()
{
Messenger::IMsgrObject2Ptr oMsgrObj = NULL;
Messenger::IMsgrUsersPtr oUsers = NULL;
Messenger::IMsgrUserPtr oUser = NULL;
SAFEARRAYBOUND rgsaBound[1];
long rgIndices[1];
HRESULT hr;

// Cria uma instância do Instant Messenger.
oMsgrObj.CreateInstance("Messenger.MsgrObject");
// Obtém a lista de contatos
oUsers = oMsgrObj-
>GetList(Messenger::MLIST_CONTACT);
// Armazena o número de contatos que você tem.
lCount = oUsers->GetCount();
rgsaBound[0].lLbound = 0;
rgsaBound[0].cElements = lCount;
// Cria um SAFEARRAY para armazenar a lista de
contatos.
psa = SafeArrayCreate(VT_VARIANT, 1, rgsaBound);
// Faz um loop por todos os contatos.
for (long l=0; l<lCount-1; l++)
{
rgIndices[0] = l;
// Configura o usuário específico.
oUser = oUsers->Item(l);
// Converte o Nome Amigável para caixa baixa
// e armazena em uma VARIANT.
_variant_t v = _wcslwr(oUser-
>GetFriendlyName());
// Coloca a VARIANT no SAFEARRAY.
hr = SafeArrayPutElement(psa, rgIndices, &v);
}
}

CRecognizer::~CRecognizer()
{
// Destrói o SAFEARRAY.
SafeArrayDestroy(psa);
}


HRESULT CRecognizer::get_ProgId(BSTR * ProgId)
{
// Configura o ProgID da interface do Recognizer.
*ProgId =
SysAllocString(L"MessengerSmartTag.Recognizer");
return S_OK;
}

HRESULT CRecognizer::get_Name(INT LocaleID, BSTR * Name)
{
// Retorna um breve título sobre o reconhecedor.
*Name = SysAllocString(L"Microsoft Messenger
Contacts Visual C++ Recognizer");
return S_OK;
}

HRESULT CRecognizer::get_Desc(INT LocaleID, BSTR * Desc)
{
// Retorna uma descrição longa do reconhecedor.
*Desc = SysAllocString(L"Microsoft Messenger
recognizes your Instant Messenger Contacts");
return S_OK;
}

HRESULT CRecognizer::get_SmartTagCount(INT * Count)
{
// Configura o número de Marcas Inteligentes que são
suportadas.
*Count = 1;
return S_OK;
}

HRESULT CRecognizer::get_SmartTagName(INT SmartTagID,
BSTR * Name)
{
// Este método é chamado o mesmo número de vezes que
você
// retorna em SmartTagCount. Este método configura
um nome único
// para a marca inteligente.
*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)
{
// O método Recognize é chamado e recebe um valor de
texto.
// Você deve reconhecer strings no texto e
configurar as ações.
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;

// Obtém o nome de contato.
_variant_t v;
hr = SafeArrayGetElement(psa,rgIndices,&v);
// Converte a VARIANT para um 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 arquivo de Action.h e substitua o conteúdo da
classe pelo seguinte código:
////////////////////////////////////////////////////////
/////////////////////
// CAction
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:
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)
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);
};
10. Abra o arquivo de Action.cpp e adicione o seguinte
código no final do arquivo:
HRESULT CAction::get_ProgId(BSTR * ProgId)
{
// Configura o ProgID da interface Action
*ProgId =
SysAllocString(L"MessengerSmartTag.Action");
return S_OK;
}

HRESULT CAction::get_Name(INT LocaleID, BSTR * Name)
{
// Configura um nome curto que descreve a Action.
*Name = SysAllocString(L"Messenger Smart Tag");
return S_OK;
}

HRESULT CAction::get_Desc(INT LocaleID, BSTR * Desc)
{
// Configura uma descrição longa que descreve a ação.
*Desc = SysAllocString(L"Provides actions for the
Messenger Smart Tag");
return S_OK;
}

HRESULT CAction::get_SmartTagCount(INT * Count)
{
// Configura o número de marcas inteligentes que
essa ação suporta.
*Count = 1;
return S_OK;
}

HRESULT CAction::get_SmartTagName(INT SmartTagID, BSTR *
Name)
{
// Este método é chamado o mesmo número de vezes que
você
// retorna em SmartTagCount. Este método configura
um nome único
// para a marca inteligente.
*Name =
SysAllocString(L"microsoft/messenger#contacts");
return S_OK;
}

HRESULT CAction::get_SmartTagCaption(INT SmartTagID, INT
LocaleID, BSTR * Caption)
{
// Essa legenda é exibida no menu da marca
inteligente.
*Caption = SysAllocString(L"Messenger Smart Tag");
return S_OK;
}

HRESULT CAction::get_VerbCount(BSTR SmartTagName, INT *
Count)
{
// Retorna o número de verbos que suportamos.
if
(wcsstr(SmartTagName,L"microsoft/messenger#contacts") !=
0) {
*Count = 2;
}
return S_OK;
}

HRESULT CAction::get_VerbID(BSTR SmartTagName, INT
VerbIndex, INT * VerbID)
{
// Retorna um ID único para cada verbo que
suportamos.
*VerbID = VerbIndex;
return S_OK;
}

HRESULT CAction::get_VerbCaptionFromID(INT VerbID, BSTR
ApplicationName,
INT LocaleID, BSTR * Caption)
{
// Configura uma legenda para cada verbo. Essa
legenda é exibida
// no menu da marca inteligente.
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)
{
// Esse método é chamado quando um usuário invoca um
verbo
// a partir do menu da marca inteligente.
Messenger::IMessengerApp2Ptr oMessenger = NULL;
Messenger::IMsgrObject2Ptr oMsgrObj = NULL;
Messenger::IMsgrUsersPtr oUsers = NULL;
Messenger::IMsgrUserPtr oUser = NULL;
_variant_t v;

// Cria uma instância do Instant Messenger.
oMessenger.CreateInstance("Messenger.MessengerApp");
oMsgrObj.CreateInstance("Messenger.MsgrObject");
// Obtém uma lista de contatos.
oUsers = oMsgrObj-
>GetList(Messenger::MLIST_CONTACT);
// Faz um loop por todos os contatos.
for (long l=0; l<(oUsers->GetCount()-1); l++)
{
// Obtém um contato específico.
oUser = oUsers->Item(l);
// Verifica se o contato é o correto.
if (wcscmp(_wcslwr(oUser-
>GetFriendlyName()),_wcslwr(Text)) == 0)
{
switch (VerbID) {
case 1:
// O usuário quer exibir a caixa Instant
Message
// para enviar uma mensagem ao contato.
v = oUser.GetInterfacePtr();
oMessenger->LaunchIMUI(v);
break;
case 2:
// Abre (Shell) o protocolo "mailto"
para iniciar o
// o programa de correio eletrônico do
usuário e criar uma nova mensagem.
_bstr_t bstrTemp = "mailto:";
bstrTemp += oUser->GetEmailAddress();
ShellExecute(0,"open",bstrTemp,NULL,NULL,1);
break;
}
}
}
return S_OK;
}
11. Abra o arquivo de Stdafx.h e adicione a seguinte
linha depois da linha que contém #include <atlcom.h>:
#import "C:\Program Files\Messenger\msmsgs.exe"
OBSERVAÇÃO: Altere o caminho do arquivo Msmsgs.exe para
o ponto de instalação do Instant Messenger. A
localização padrão do Instant Messenger é C:\Arquivos de
Programas\Messenger.
12. Pressione F7 para construir a DLL.

Passos para registrar a DLL de Marca Inteligente
Antes de você poder utilizar qualquer DLL de Marca
Inteligente, você deve registrá-la no sistema. O registro
normal de COM é feito para você quando você compila o
projeto ou chama Regsvr32.exe com o nome DLL. Você deve
criar entradas adicionais de registro que não são parte do
registro normal de COM de modo que aplicativos do Office
possam identificar a DLL como uma DLL de Marca Inteligente.
Para fazer isso, siga estes passos:
1.A partir de uma linha de comando, inicie Regedit.exe.
2.Em At
HKEY_CURRENT_USER\Software\Microsoft\Office\Common\Smart
Tag\Actions, adicione uma nova subchave chamada
MessengerSmartTag.Action.
3.Em
HKEY_CURRENT_USER\Software\Microsoft\Office\Common\Smart
Tag\Recognize, adicione uma nova subchave chamada
MessengerSmartTag.Recognize.
4.Feche o Registry Editor.

Passos para testar a DLL de Marca Inteligente
As Marcas inteligentes obedecem ao mesmo modelo de
segurança que as macros. Se as configurações de segurança
do aplicativo estiverem configuradas como Alta, a DLL de
Marca Inteligente não carrega a menos que a DLL seja
digitalmente assinada (como também o caso com as macros de
VBA). Para as informações adicionais sobre assinaturas
digitais, veja a seção ?Referências?.
Para testar a DLL Smart Tag Recognizer/Action no Word, siga
estes passos:
1.Inicie o Instant Messenger e efetue logon.
OBSERVAÇÃO: O exemplo de Marca Inteligente requer que
você efetue logon no Instant Messenger; se você não
estiver conectado ao Instant Messenger, a DLL
personalizada carrega mas não reconhece nenhum contato.
2.Inicie o Word 2002. No menu Ferramentas, aponte para
Macro e clique em Segurança. Configure a segurança de
macro como Média e clique em OK. Se a configuração de
segurança de macro foi anteriormente configurada como
Alta, reinicie o Word.
3.Digite um nome de contato amigável em um novo documento
(por exemplo, John Smith), e então pressione ENTER. Uma
linha suave aparece embaixo do nome amigável para
indicar que ele é reconhecido como uma Marca
Inteligente. Mova o mouse sobre o nome amigável, e o
botão Ação de Marca Inteligente aparece.
4.Clique Smart Tag Action, e selecione um dos itens ação
personalizada no menu drop-down. Você pode enviar um
correio eletrônico ou mensagens instantâneas para o
contato a partir de seu novo documento.
Você pode utilizar passos semelhantes para testar a DLL de
Marca Inteligente no Excel 2002.

Solução de problemas
Se você tiver problemas em fazer suas Marcas Inteligentes
personalizadAs funcionarem, primeiro certifique-se de que a
DLL de Marca Inteligente personalizada está sendo
carregada. No Word ou Excel, no menu Ferramentas, clique em
Opções de Autocorreção, clique na guia Marca Inteligente, e
certifique-se de Rótulo de Texto com Marcas Inteligentes
está selecionado e que sua DLL de Marca Inteligente está
listada e selecionada. Se seu Marca Inteligente não estiver
listada, ela pode não estar adequadamente registrado.
Se a execução da classe personalizada recognizer ou action
for a fonte do problema, você pode depurar uma DLL de Marca
Inteligente como faria com qualquer Visual C++ DLL.
Configure um ponto de interrupção no construtor para a
classe de Recognizer. Quando você pressiona F5 para depurar
o aplicativo, uma caixa de diálogo aparece e pede um
arquivo executável para a sessão de depuração. Selecione
Winword.exe ou Excel.exe. Quando o Excel ou o Word iniciar
e carregar a Marca Inteligente, seu código pára no ponto de
interrupção e você pode percorrer o código passo a passo
para depuração.

REFERÊNCIAS
A documentação para essas interfaces, junto com a
biblioteca de tipos necessária que os define, é fornecido
no Smart Tag Software Development Kit (SDK). Se ainda não
fez isso, você deve instalar o Smart Tag SDK antes de
prosseguir com Passos para criar o exemplo de Marca
Inteligente. Você pode obter o Smart Tag SDK do CD-ROM
Microsoft Office XP Developer (MOD), ou pode fazer download
dele do seguinte site da Web da Developer Network (MSDN):
Smart Tag Software Development Kit
http://msdn.microsoft.com/downloads/default.asp?URL=/c
ode/sample.asp?url=/MSDN-
FILES/027/001/652/msdncompositedoc.xml
Para informações adicionais sobre como criar Smart Tag
Recognizer/Action DLLs, veja o arquivo Smart Tag
Development Help incluído no Smart Tag SDK.
Para informações adicionais sobre assinaturas digitais,
clique no número de artigo abaixo para ver o artigo na
Microsoft Knowledge Base:
Q247257: INFO: Passos para assinar um arquivo .cab
Para informações sobre como utilizar CLSIDs para registrar
a DLL de Marca Inteligente em vez de ProgIDs, veja o
seguinte artigo na Microsoft Knowledge Base:
Q294422: BUG: O flag de status não é atualizado ao
ativar ou desativar Marcas Inteligentes

Propriedades

ID do artigo: 292596 - Última revisão: segunda-feira, 24 de fevereiro de 2014 - Revisão: 1.0
A informação contida neste artigo aplica-se a:
  • Microsoft Visual C++ 6.0 Professional Edition
  • Microsoft Excel 2002 Standard Edition
  • Microsoft Word 2002 Standard Edition
Palavras-chave: 
kbnosurvey kbarchive KB292596

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