CÓMO: Crear un archivo DLL de etiquetas inteligentes en ATL para utilizarlo en Office XP

Seleccione idioma Seleccione idioma
Id. de artículo: 292596 - Ver los productos a los que se aplica este artículo
Este artículo se publicó anteriormente con el número E292596
Este artículo se ha archivado. Se ofrece "tal cual" y no se volverá a actualizar.
Expandir todo | Contraer todo

En esta página

Resumen

Las etiquetas inteligentes son una tecnología introducida con Office XP que proporciona a los usuarios de Office más interactividad con el contenido de sus documentos de Office. Una etiqueta inteligente es un elemento de texto en un documento de Office que tiene asociadas acciones personalizadas. Un ejemplo de uno de estos elementos especiales de texto puede ser el nombre de un mensaje de correo electrónico escrito en un documento de Word o en un libro de Excel. Si el nombre del mensaje de correo electrónico se reconoce como una etiqueta inteligente, se presentarán al usuario una o más acciones que puede realizar sobre dicho texto. Entre las posibles acciones asociadas al nombre del mensaje de correo electrónico están la búsqueda de información adicional sobre un contacto o el envío de un nuevo mensaje de correo electrónico a dicho contacto.

Puede ampliar las capacidades de Office XP si desarrolla su propia biblioteca de vínculos dinámicos (DLL) de reconocimiento y acción de etiquetas inteligentes para su uso con documentos de Office. En este artículo se describe cómo crear un archivo DLL de etiquetas inteligentes mediante la Biblioteca de plantillas activas (ATL) y se explica la configuración del Registro necesaria para que Office XP identifique y utilice el archivo DLL de etiquetas inteligentes.

NOTA: Excel 2002 y Word 2002 son las únicas aplicaciones de Office XP que admiten etiquetas inteligentes. Sin embargo, la información que se muestra en este artículo puede aplicarse al desarrollo de etiquetas inteligentes en cualquier aplicación que adopte la tecnología de etiquetas inteligentes. Un archivo de etiquetas inteligentes es un archivo de modelo de objetos de componentes (COM) que implementa dos interfaces especiales: ISmartTagRecognizer e ISmartTagAction. La interfaz ISmartTagRecognizer reconoce el texto escrito en un documento como una etiqueta inteligente. La interfaz ISmartTagAction realiza acciones en una cadena concreta de etiquetas inteligentes a petición del usuario. No es necesario implementar estas interfaces en el mismo archivo DLL. Puede tener un archivo DLL de reconocimiento y, a continuación, uno o más archivos DLL de acción que extiendan un único tipo de etiqueta inteligente para diferentes acciones.




Pasos para crear el archivo DLL de etiquetas inteligentes en ATL


Con los siguientes pasos se crea un sencillo archivo DLL de etiquetas inteligentes que reconoce los contactos de Instant Messenger de Microsoft Network (MSN) y permite al usuario enviar mensajes de correo electrónicos o instantáneos a un contacto reconocido. Se requiere Instant Messenger para utilizar este ejemplo. Si no tiene Instant Messenger, puede obtener una copia desde el siguiente sitio Web de MSN:
http://messenger.msn.es/

  1. En Visual C++, cree un nuevo proyecto en el Asistente de aplicaciones COM ATL. Asígnele el nombre MessengerSmartTag.
  2. Haga clic en Aceptar para ejecutar el asistente para COM ATL. En el siguiente cuadro de diálogo, asegúrese de que Biblioteca de vínculos dinámicos está seleccionada y haga clic en Finalizar. Haga clic en Aceptar para crear el proyecto.
  3. Para crear la clase Recognizer en el menú Insertar, haga clic en Nuevo objeto ATL. Haga clic en Objeto simple y, a continuación, en Siguiente. Para el nombre abreviado, escriba Recognizer y haga clic en Aceptar.
  4. Para crear la clase Action, siga las instrucciones del paso 3, pero escriba Action para el nombre abreviado.
  5. Abra ClassView y expanda Clases MessengerSmartTag. Haga clic con el botón secundario del mouse (ratón) en la clase CRecognizer y seleccione Implementar interfaz. Haga clic en Aceptar en el cuadro de diálogo de advertencia que aparece. Haga clic en Examinar y seleccione Biblioteca de tipos Microsoft Smart Tags 1.0. Seleccione la interfaz ISmartTagRecognizer y presione Aceptar.

    NOTA: La ubicación predeterminada de la Biblioteca de tipos Microsoft Smart Tags 1.0 es C:\Archivos de programa\Archivos comunes\Microsoft Shared\Mstag.tlb.
  6. En ClassView, haga clic con el botón secundario del mouse (ratón) en la clase CAction y seleccione Implementar interfaz. Haga clic en Aceptar en el cuadro de diálogo de advertencia que aparece. Haga clic en Examinar y seleccione Biblioteca de tipos Microsoft Smart Tags 1.0. Seleccione la interfaz ISmartTagAction y haga clic en Aceptar.
  7. Abra el archivo Recognizer.h y reemplace el contenido de la clase por el siguiente 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) 
    //Eliminada -- 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 el archivo Recognizer.cpp y agregue el siguiente código al final del mismo:
     
    CRecognizer::CRecognizer() 
    { 
    Messenger::IMsgrObject2Ptr oMsgrObj = NULL; 
    Messenger::IMsgrUsersPtr oUsers = NULL; 
    Messenger::IMsgrUserPtr oUser = NULL; 
    SAFEARRAYBOUND rgsaBound[1]; 
    long rgIndices[1];		
     HRESULT hr; 	
    	 
    // Crear una instancia de Instant Messenger. 
    oMsgrObj.CreateInstance("Messenger.MsgrObject"); 
    // Obtener una lista de contactos 
    oUsers = oMsgrObj->GetList(Messenger::MLIST_CONTACT); 
    // Almacenar el número de contactos. lCount = oUsers->GetCount(); 
    rgsaBound[0].lLbound = 0; 
    rgsaBound[0].cElements = lCount; 
    // Crear un SAFEARRAY para guardar los contactos. 
    psa = SafeArrayCreate(VT_VARIANT, 1, rgsaBound); 
    // Recorrer todos los contactos. for (long l=0; l<lCount-1; l++) 
    { 
    	rgIndices[0] = l;
    	// Establecer el usuario específico. 
    	oUser = oUsers->Item(l);
    	 // Pasar el nombre abreviado a minúsculas 
    	// y almacenarlo en VARIANT. 
    	_variant_t v = _wcslwr(oUser->GetFriendlyName()); 
    	// Poner VARIANT en SAFEARRAY. 
    	hr = SafeArrayPutElement(psa, rgIndices, &v); } 
    }
    
    CRecognizer::~CRecognizer() 
    { 
    	// Destruir SAFEARRAY. 
    	SafeArrayDestroy(psa); 
    }
    
     HRESULT CRecognizer::get_ProgId(BSTR * ProgId) 
    { 
    	// Establecer el ProgID de la interfaz Recognizer. 
    	*ProgId = SysAllocString(L"MessengerSmartTag.Recognizer"); 
    	return S_OK; 
    }
    
    HRESULT CRecognizer::get_Name(INT LocaleID, BSTR * Name) 
    { 
    	// Establecer un título abreviado para el reconocedor. 
    	*Name = SysAllocString(L"Microsoft Messenger Contacts Visual C++ Recognizer"); 
    	return S_OK; 
    }
    
    HRESULT CRecognizer::get_Desc(INT LocaleID, BSTR * Desc) 
    { 
    	// Establecer una descripción larga del recognizer. 
    	*Desc = SysAllocString(L"Microsoft Messenger reconoce los contactos de Instant Messenger"); 
    	return S_OK; 
    }
    
    HRESULT CRecognizer::get_SmartTagCount(INT * Count) 
    { 
    	// Establecer el número de etiquetas inteligentes admitidas. 
    	*Count = 1; return S_OK; 
    }
    
    HRESULT CRecognizer::get_SmartTagName(INT SmartTagID, BSTR * Name) 
    { 
    	// Este método se llama tantas veces como
    	// establezca en SmartTagCount. Este método establece un nombre único 
    	// para la etiqueta inteligente. 
    	*Name = SysAllocString(L"microsoft/messenger#contacts"); 
    	return S_OK; 
    }
    
    HRESULT CRecognizer::get_SmartTagDownloadURL(INT SmartTagID, BSTR * DownloadURL) 
    { 
    	// Establece la dirección URL que se integra en documentos. 
    	*DownloadURL = NULL; return S_OK; 
    }
    
    HRESULT CRecognizer::Recognize(BSTR Text, IF_TYPE DataType, INT LocaleID, 
    ISmartTagRecognizerSite * RecognizerSite) 
    { 
    	// Se llama al método Recognize y se le pasa un valor de texto. 
    	// Debería reconocer cadenas en el texto y establecer las acciones. 
    	WCHAR *pch, *strText = _wcslwr(Text); 
    	ISmartTagProperties *pSmartTagProp = NULL; 
    	long rgIndices[1]; 
    	HRESULT hr;
    
    
    	 // Busque (long l = 0; l<lCount; l++)
    	 en todos los contactos. 
    { 
    	rgIndices[0] = l;
    
    
     	// Obtenga el nombre del contacto. 
    	_variant_t v; 
    	hr = SafeArrayGetElement(psa,rgIndices,&v); 
    	// Convierta VARIANT en BSTR. _bstr_t bstrContact = v; 
    	// Recorrer la cadena buscando contactos. 
    	for (pch = strText; (pch = wcsstr(pch, bstrContact))!=NULL; pch++) 
    	{ 
    	 // Crear una nueva bolsa de propiedades. 
    	hr = RecognizerSite->GetNewPropertyBag(&pSmartTagProp); 
    	if (SUCCEEDED(hr)) 
    	{  
    		// Guarde la etiqueta inteligente en la bolsa de propiedades.		
    		 hr = RecognizerSite->CommitSmartTag(  
    		_bstr_t("microsoft/messenger#contacts"),  
    		pch - strText+1, wcslen(bstrContact),  
    		pSmartTagProp);  
    
    	if (pSmartTagProp != NULL) 
    	pSmartTagProp->Release(); 
    		} 
    	} 
    } 
    return S_OK; 
    }
  9. Abra el archivo Action.h y reemplace el contenido de la clase por el siguiente 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 el archivo Action.cpp y agregue el siguiente código al final del mismo:
     
    	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. Abrir el archivo Stdafx.h y agregar la siguiente línea tras la línea que dice #include <atlcom.h>:
     #import "C:\Archivos de programa\Messenger\msmsgs.exe"
    NOTA: cambie la ruta de acceso al archivo Msmsgs.exe por el punto de instalación para Instant Messenger. La ubicación predeterminada para Instant Messenger es C:\Archivos de programa\Messenger.
  12. Presione F7 para crear el archivo DLL.




Pasos para registrar el archivo DLL de etiquetas inteligentes



Antes de utilizar un archivo DDL de etiquetas inteligentes, debe registrarlo en el sistema. El registro normal de COM se realiza cuando compila el proyecto o llama a Regsvr32.exe con el nombre DLL. Debe crear entradas adicionales en el Registro que no formen parte del registro normal de COM con el fin de que las aplicaciones de Office puedan identificar el archivo DLL como un archivo DLL de etiquetas inteligentes. Para ello, siga estos pasos:
  1. Desde una línea de comandos, ejecute Regedit.exe.
  2. En HKEY_CURRENT_USER\Software\Microsoft\Office\Common\Smart Tag\Actions, agregue una subclave denominada MessengerSmartTag.Action.
  3. En HKEY_CURRENT_USER\Software\Microsoft\Office\Common\Smart Tag\Recognize agregue una nueva subclave denominada MessengerSmartTag.Recognize.
  4. Cierre el Editor del Registro.




Pasos para comprobar el archivo DLL de etiquetas inteligentes



Las etiquetas inteligentes siguen el mismo modelo de seguridad que las macros. Si la configuración de seguridad de la aplicación está establecida como Alta, el archivo DLL de etiquetas inteligentes no se cargará a menos que este archivo esté firmado digitalmente (al igual que ocurre con las macros de VBA). Para obtener información acerca de las firmas digitales, consulte la sección "Referencias".

Para comprobar un archivo DLL Recognizer/Action de etiquetas inteligentes en Word, siga estos pasos:
  1. Ejecute Instant Messenger e inicie sesión.

    NOTA: la etiqueta inteligente de ejemplo requiere que inicie sesión en Instant Messenger; de lo contrario, el archivo DLL se cargará, pero no reconocerá ningún contacto.
  2. Inicie Word 2002. En el menú Herramientas, seleccione Macros y haga clic en Seguridad. Establezca la seguridad de las macros como Media y, a continuación, haga clic en Aceptar. Si la configuración de seguridad de las macros se estableció anteriormente como Alta, reinicie Word.
  3. Escriba el nombre descriptivo de un contacto en un nuevo documento (por ejemplo, Juan Martínez) y presione ENTRAR. Debajo del nombre descriptivo aparecerá una débil línea que indica que se reconoce como una etiqueta inteligente. Coloque el mouse (ratón) sobre el nombre descriptivo. Aparecerá el botón Acción de etiquetas inteligentes.
  4. Haga clic en Acción de etiquetas inteligentes y seleccione uno de los elementos de acción personalizados del menú desplegable. Puede enviar un mensaje de correo electrónico o un mensaje instantáneo al contacto desde el nuevo documento.
Puede seguir pasos similares para probar el archivo DLL de etiquetas inteligentes en Excel 2002.





Solución de problemas



Si tiene problemas con el funcionamiento de las etiquetas inteligentes personalizadas, asegúrese primero de que se está cargando el archivo DLL de etiquetas inteligentes personalizadas. En Word o Excel, en el menú Herramientas, haga clic en Opciones de Autocorrección y en la ficha Etiqueta inteligente; asegúrese de que la opción Marcar texto con etiquetas inteligentes está seleccionada y de que su archivo DLL de etiquetas inteligentes aparece y está seleccionado. Si la etiqueta inteligente no aparece, es posible que no esté registrada correctamente.

Si la ejecución de las clases personalizadas recognizer o action es el origen del problema, puede depurar un archivo DLL de etiquetas inteligentes como lo haría con cualquier otro archivo DLL de Visual C++. Establezca un punto de interrupción en el constructor para la clase Recognizer. Cuando presione F5 para depurar la aplicación, aparecerá un cuadro de diálogo que le pedirá un archivo ejecutable para la sesión de depuración. Seleccione Winword.exe o Excel.exe. Cuando Excel o Word inicie y cargue la etiqueta inteligente, su código se detendrá en el punto de interrupción y podrá examinarlo para su depuración.



REFERENCIAS


La documentación para estas interfaces junto con la biblioteca de tipos necesaria que las define se proporciona en el Kit de desarrollo de software (SDK) de etiquetas inteligentes. Si todavía no lo ha hecho, instale el SDK de etiquetas inteligentes antes de continuar con los pasos para crear la etiqueta inteligente de ejemplo. Puede obtener el SDK de etiquetas inteligentes desde el CD-ROM de Microsoft Office XP Developer (MOD), o bien puede descargarlo desde el siguiente sitio Web de Microsoft Developer Network (MSDN):
Kit de desarrollo del software de etiquetas inteligentes
http://www.microsoft.com/downloads/details.aspx?familyid=3d8edcee-0246-43ef-a70f-94c0899f1e8f&displaylang=en



Para obtener más información acerca de cómo crear archivos DLL Recognizer/Action de etiquetas inteligentes, consulte el archivo de Ayuda para el desarrollo de etiquetas inteligentes incluido con el SDK de etiquetas inteligentes.

Para obtener información adicional acerca de las firmas digitales, haga clic en el número de artículo siguiente para verlo en Microsoft Knowledge Base:
247257 INFO: Steps for Signing a .cab File
Para obtener información acerca de cómo utilizar los CLSID para registrar el archivo DLL de etiquetas inteligentes en lugar de los ProgID, consulte el siguiente artículo en Microsoft Knowledge Base:
294422 BUG: Status Flag Is Not Updated When You Enable or Disable Smart Tags




Propiedades

Id. de artículo: 292596 - Última revisión: lunes, 24 de febrero de 2014 - Versión: 7.1
La información de este artículo se refiere a:
  • Microsoft Excel 2002 Standard Edition
  • Microsoft Word 2002 Standard Edition
  • Microsoft Visual C++ 6.0 Professional
Palabras clave: 
kbnosurvey kbarchive kbatl kbgrpdso kbhowtomaster KB292596

Enviar comentarios

 

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