Cómo incrustar y automatizar una hoja de cálculo de Microsoft Excel con MFC

Seleccione idioma Seleccione idioma
Id. de artículo: 184663 - Ver los productos a los que se aplica este artículo
Expandir todo | Contraer todo

Resumen

En este artículo se describe cómo incrustar una hoja de cálculo de Microsoft Excel en un objeto View en una aplicación MFC SDI.

Este artículo incluye instrucciones paso a paso para incrustar la hoja de cálculo y agregar texto a la celda A1, así como comentarios que explican cada paso.

Aunque se puede tomar el código de ejemplo de este artículo y colocarlo en su aplicación, la ventaja real procede de leer y entender el código de ejemplo.

Más información

Microsoft proporciona ejemplos de programación solamente como ilustración, sin ninguna garantía ya sea expresa o implícita. Esto incluye, entre otras, las garantías implícitas de comerciabilidad e idoneidad para un fin determinado. En este artículo se da por supuesto que ya conoce el lenguaje de programación que se muestra, así como las herramientas empleadas para crear y depurar procedimientos. Los ingenieros de soporte técnico de Microsoft pueden ayudar a explicar la funcionalidad de un procedimiento en particular. Sin embargo, no modificarán estos ejemplos para proporcionar una funcionalidad adicional ni crearán procedimientos que cumplan sus requisitos específicos.

Para crear la aplicación MFC, siga estos pasos:
  1. Utilice el Asistente para aplicaciones con el fin de crear un nuevo proyecto de Asistente para aplicaciones MFC (EXE) denominado "Embed_Excel".
  2. Seleccione Single Document como el tipo de aplicación que se va a crear y seleccione Container como el tipo de compatibilidad con documentos compuestos que se va a incluir. Acepte todas las demás configuraciones predeterminadas.

    Se generarán las clases siguientes:

    Application: CEmbed_ExcelApp en Embed_Excel.h y Embed_Excel.cpp

    Frame: CMainFrame en MainFrm.h y MainFrm.cpp

    Document: CEmbed_ExcelDoc en Embed_ExcelDoc.h y Embed_ExcelDoc.cpp

    View: CEmbed_ExcelView en Embed_ExcelView.h y Embed_ExcelView.cpp

    Container Item: CEmbed_ExcelCntrItem en CntrItem.h y CntrItem.cpp
  3. En el menú Ver, haga clic en ClassWizard. Haga clic en la ficha Automatización, haga clic en Agregar clase y elija Desde una biblioteca de tipos. Busque la Biblioteca de tipos de Microsoft Excel y agregue todas las clases de la biblioteca de tipos a su proyecto. En Excel 97, la biblioteca de tipos se encuentra en Excel8.olb. En Excel 2000, la biblioteca de tipos se encuentra en Excel9.olb y en Excel 2002 y en versiones posteriores, la biblioteca de tipos está en Excel.exe.
  4. Agregue la línea siguiente a CntrItem.h:
    LPDISPATCH GetIDispatch();
    					
  5. A continuación, agregue el método GetIDispatch a CntrItem.cpp:
       Sample Code
       -----------
    
    
          /*******************************************************************
          *   This method returns the IDispatch* for the application linked to
          *   this container.
          ********************************************************************/ 
          LPDISPATCH CEmbed_ExcelCntrItem::GetIDispatch()
          {
             //The this and m_lpObject pointers must be valid for this function
             //to work correctly. The m_lpObject is the IUnknown pointer to
             // this object.
             ASSERT_VALID(this);
    
             ASSERT(m_lpObject != NULL);
    
             LPUNKNOWN lpUnk = m_lpObject;
    
             //The embedded application must be running in order for the rest
             //of the function to work.
             Run();
    
             //QI for the IOleLink interface of m_lpObject.
             LPOLELINK lpOleLink = NULL;
             if (m_lpObject->QueryInterface(IID_IOleLink,
                (LPVOID FAR*)&lpOleLink) == NOERROR)
             {
                ASSERT(lpOleLink != NULL);
                lpUnk = NULL;
    
                //Retrieve the IUnknown interface to the linked application.
                if (lpOleLink->GetBoundSource(&lpUnk) != NOERROR)
                {
                   TRACE0("Warning: Link is not connected!\n");
                   lpOleLink->Release();
                   return NULL;
                }
                ASSERT(lpUnk != NULL);
             }
    
             //QI for the IDispatch interface of the linked application.
             LPDISPATCH lpDispatch = NULL;
             if (lpUnk->QueryInterface(IID_IDispatch, (LPVOID FAR*)&lpDispatch)
                !=NOERROR)
             {
                TRACE0("Warning: does not support IDispatch!\n");
                return NULL;
             }
    
             //After assuring ourselves it is valid, return the IDispatch
             //interface to the caller.
             ASSERT(lpDispatch != NULL);
             return lpDispatch;
          }
    					
  6. Agregue la línea siguiente a Embed_ExcelView.h:
          void EmbedAutomateExcel();
    					
  7. Después, agregue el método EmbedAutomateExcel a Embed_ExcelView.cpp:
    Sample Code
    -----------
          /********************************************************************
          *   This method encapsulates the process of embedding an Excel
          *   Worksheet in a View object and automating that worksheet to add
          *   some text to cell A1.
          ********************************************************************/ 
          void CEmbed_ExcelView::EmbedAutomateExcel()
          {
             //Change the cursor so the user knows something exciting is going
             //on.
             BeginWaitCursor();
    
             CEmbed_ExcelCntrItem* pItem = NULL;
             TRY
             {
                //Get the document associated with this view, and be sure it's
                //valid.
                CEmbed_ExcelDoc* pDoc = GetDocument();
                ASSERT_VALID(pDoc);
    
                //Create a new item associated with this document, and be sure
                //it's valid.
                pItem = new CEmbed_ExcelCntrItem(pDoc);
                ASSERT_VALID(pItem);
    
                // Get Class ID for Excel sheet.
                // This is used in creation.
                CLSID clsid;
                if(FAILED(::CLSIDFromProgID(L"Excel.sheet",&clsid)))
                   //Any exception will do. We just need to break out of the
                   //TRY statement.
                   AfxThrowMemoryException();
    
                // Create the Excel embedded item.
                if(!pItem->CreateNewItem(clsid))
                   //Any exception will do. We just need to break out of the
                   //TRY statement.
                   AfxThrowMemoryException();
    
                //Make sure the new CContainerItem is valid.
                ASSERT_VALID(pItem);
    
                // Launch the server to edit the item.
                pItem->DoVerb(OLEIVERB_SHOW, this);
    
    
                // As an arbitrary user interface design, this sets the
                // selection to the last item inserted.
                m_pSelection = pItem;   // set selection to last inserted item
                pDoc->UpdateAllViews(NULL);
    
                //Query for the dispatch pointer for the embedded object. In
                //this case, this is the Excel worksheet.
                LPDISPATCH lpDisp;
                lpDisp = pItem->GetIDispatch();
    
                //Add text in cell A1 of the embedded Excel sheet
                _Workbook wb;
                Worksheets wsSet;
                _Worksheet ws;
                Range range;
                _Application app;
    
                //set _Workbook wb to use lpDisp, the IDispatch* of the
                //actual workbook.
                wb.AttachDispatch(lpDisp);
    
    
                //Then get the worksheet's application.
                app = wb.GetApplication();
    
                //Then get the first worksheet in the workbook
                wsSet = wb.GetWorksheets();
                ws = wsSet.GetItem(COleVariant((short)1));
    
                //From there, get a Range object corresponding to cell A1.
                range = ws.GetRange(COleVariant("A1"), COleVariant("A1"));
    
                //Fill A1 with the string "Hello, World!"
                range.SetValue(COleVariant("Hello, World!"));
    
               //NOTE: If you are automating Excel 2002, the Range.SetValue method has an 
               //additional optional parameter specifying the data type.  Because the 
               //parameter is optional, existing code will still work correctly, but new 
               //code should use the new convention.  The call for Excel2002 should look 
               //like the following:
    
               //range.SetValue( C<?xm-insertion_mark_start author="v-thomr" time="20070326T121607-0600"?>O<?xm-insertion_mark_end?><?xm-deletion_mark author="v-thomr" time="20070326T121606-0600" data="o"?>leVariant( (long)DISP_E_PARAMNOTFOUND, VT_ERROR ), 
               //                COleVariant("Hello, World!"));
             }
    
               //Here, we need to do clean up if something went wrong.
               CATCH(CException, e)
               {
                  if (pItem != NULL)
                  {
                     ASSERT_VALID(pItem);
                     pItem->Delete();
    
                  }
                  AfxMessageBox(IDP_FAILED_TO_CREATE);
               }
               END_CATCH
    
               //Set the cursor back to normal so the user knows exciting stuff
               //is no longer happening.
               EndWaitCursor();
            }
    
    					
  8. Agregue la línea siguiente a Embed_ExcelView.h:
          #include "excel8.h"
    						
    Nota: si va a automatizar Excel 2000, el archivo de encabezado es "excel9.h". Si va a automatizar Excel 2002 o una versión posterior de Excel, el archivo de encabezado es "excel.h".
  9. Examine el método OnInsertObject() de la clase View. Es interesante destacar que este método, y el método que acabamos de escribir, son muy similares. De hecho, el código que hemos escrito es simplemente un caso especial de OnInsertObject(), que permite al usuario elegir entre una lista de objetos OLE disponibles para insertar en la aplicación. Puesto que sólo deseamos automatizar la hoja de cálculo de Excel, omitiremos este comportamiento. Para nuestra aplicación, quite todo el código del interior de InsertObject() y reemplácelo con una llamada a EmbedAutomateExcel().
  10. Compile y ejecute la aplicación.
  11. En el menú Edición, haga clic en Insertar nuevo objeto.
Resultados: se incrusta una hoja de cálculo de Microsoft Excel en la vista. Además, la celda A1 se llena con "Hello, World!" mediante automatización.

Propiedades

Id. de artículo: 184663 - Última revisión: jueves, 27 de diciembre de 2007 - Versión: 5.0
La información de este artículo se refiere a:
  • Microsoft Office Excel 2007
  • Microsoft Office Excel 2003
  • Microsoft Excel 2002 Standard Edition
  • Microsoft Excel 2000 Standard Edition
  • Microsoft Excel 97 Standard Edition
  • Microsoft Visual C++ 5.0 Professional
  • Microsoft Visual C++ 6.0 Professional
  • Microsoft Foundation Class Library 4.2
  • Microsoft Office XP Developer Edition
  • Microsoft Office 2000 Developer Edition
Palabras clave: 
kbhowto kbinterop kbprogramming kbautomation KB184663

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