5. Excel - Beispiel und Wrapperklasse für Excelautomation

Excel - Beispiel und Wrapperklasse für Excelautomation

  • C

    Hallo,
    da ich jetzt Wochen nach der Lösung gesucht habe, mir aber keiner helfen konnte, ist es bestimmt interessant, wenn ich den Code hier einfüge:

    Variant Excel;
     Excel = Variant::CreateObject("Excel.Application");

     Excel.OlePropertyGet("ActiveWorkBook");
     // Excel-Datei öffnen
        Excel.OlePropertyGet("WorkBooks").OleFunction("Open","C:\\test.xls");

     // Sichbar machen
     Excel.OlePropertySet("Visible",1);

     Variant Sheet;
     Sheet=Excel.OlePropertyGet("ActiveSheet");
     ShowMessage(Sheet.OlePropertyGet("Cells",1,1).OlePropertyGet("Value"));

    Damit könnt ihr eine Excel-Datei öffnen und einen beliebigen Zellenwert auslesen.

    Christian

    0
  • A

    Hi,

    [Edit:] Beitrag neu aufgesetzt

    man kann, wie mein Vorgänger schon beschrieben hat und wie es auch in Happy's Beitrag in der FAQ steht über Variant- Typen auf Excel zugreifen.

    Variant stellt verschiedene Methoden zur Verfügung, die Daten aus dem Variant-Objekt holen oder schreiben. Auch können Funktionen von Excel ausgeführt werden.

    Die Methoden OlePropertyGet und OlePropertySet werden benutzt um Eigenschaften von Excel zu setzten.

    Beispiel:

    Variant var_Excel=CreateOleObject("Excel.Application");
// Eigenschaft auslesen:
bool Visible=var_Excel.OlePropertyGet("Visible");
// Eigenschaften setzen:
var_Excel.OlePropertySet("Visible",false);// unsichtbar machen

    Funktion können ähnlich benutzt werden:

    var_Excel.OleFunction("Quit");

    "Quit" ist eine Funktion von Excel, die hier aufgerufen wird.

    Jede Excel- Instanz enthält Mappen und diese wiederum Tabellen.

    Generell:

    Wenn ihr wissen wollt, was für Eigenschaften oder Methoden benutzt werden können, so geht in Excel auf Macro aufzeichnen. Macht die Änderungen, welche ihr über OLE mit Excle machen wollt und beendet das Macro.
    Geht dann in den Macro- Editor und schaut euch die sachen ma genauer an. Alle Eigenschaften oder Funktionen die dort verwendet werden könnt ihr auch benutzen.

    Hier eine geänderte Version der Excel- Wrapperklassen:

    //---------------------------------------------------------------------------

#ifndef MLExcelH
#define MLExcelH
#include <ComObj.hpp>
#include <Classes.hpp>
#include <Graphics.hpp>
class TMLWorkbook;
class TMLWorksheet;
class  TMLExcel;
//-----------------------------------------------------------------------------

//------------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                   Class TMLWorksheet
//----------------------------------------------------------------------------
class TMLWorksheet
{
private:
//Variablen
   int FMaxRows;
   int FMaxCols;
   Variant var_Sheet;
   TMLWorkbook *FParentWorkbook;
   TStringList * FRow;
   TStringList * FCol;
//Methoden
   String __fastcall GetName();
   void __fastcall SetName(String AName);
   int __fastcall GetIndex();
   int __fastcall GetColCount();
   int __fastcall GetRowCount();
   TStringList* __fastcall GetCols(int Index);
   TStringList* __fastcall GetRows(int Index);

   String __fastcall GetCellString(int Col, int Row);
   void __fastcall SetCellString(int Col, int Row, String Text);
   void __fastcall SetCellString_Range(String Range,String Text);

protected:

public:
   // Eigenschaften
   __property String Name={read= GetName,write =SetName}; //der Name der Tabelle. Wenn Sie einen neuen Name vergeben wirddieser nur akzeptiert, wenn
                                                          // dieser Name nicht in der aktuellen Arbeitsmappe voranden ist und nicht "" ist

   __property int MaxRows ={read=FMaxRows,write=FMaxRows};  // default==2000 ; Zeilenbegrenzung da in Excel die Anzahl der Zeilen nicht limitiert wird
   __property int MaxCols ={read=FMaxCols,write=FMaxCols};  // default==200  ; Spaltenbegrenzung da in Excel die Anzahl der Spalten nicht limitiert wird
   __property int Index ={read =GetIndex}; // gib den Index in der MLWorkbook- Instanz zurück
         //__property int RowCount = {read = GetRowCount};  // Anzahl der Zeilen
         //__property int ColCount = {read = GetColCount};  // Anzahl der Spalten

   __property TStringList* Cols[int Index]={read=GetCols}; // gibt die Spalte (Index) als Stringliste zurück ( bis MaxCols da sonst die Liste überlaufen würde)
   __property TStringList* Rows[int Index]={read=GetRows}; // gibt die Zeile (Index) als Stringliste zurück ( bis MaxRows da sonst die Liste überlaufen würde)

   __property String CellString[int Col][int Row]={read= GetCellString, write=SetCellString}; // Zellinhalte direkt setzen oder auslesen
   __property String CellStringByRange [String Range]={write=SetCellString_Range}; // Beispiel: String temp=Excel->Books[1]->Sheets[1]->CellStringByRange["A1:B6"]="Hallo";

   __property Variant AsVariant={read=var_Sheet};  // die Tabelle als Variant (nur verwenden wenn unbeding Notwendig!)
   __property TMLWorkbook* Parent={read=FParentWorkbook}; // die Arbeitsmappe, in der sich dies Tabelle befindet

//Methoden
         __fastcall TMLWorksheet(TMLWorkbook* AWorkbook,Variant ASheet);
         __fastcall ~TMLWorksheet();
   void __fastcall Activate(); // macht die diese Tabelle zur aktuellen Tabelle in der Arbeitsmappe 
};
//----------------------------------------------------------------------------
//                   Class TMLWorkbook
//----------------------------------------------------------------------------
class TMLWorkbook
{
private:
//Variablen
   TList * FWorksheets;
   Variant var_Book;
   Variant var_Sheet;
   TStringList * FSheetNames;
   TMLWorksheet* FActiveWorksheet;
   int FIndex;
   TMLExcel* FParentExcel;

//Methoden
   int __fastcall GetWorksheetCount();
   String __fastcall GetName();
   TStringList*__fastcall GetWorksheetNames();
   int __fastcall GetIndex();
   bool __fastcall GetConnect();
   TMLWorksheet* __fastcall GetFromWorksheets(int Index);

protected:

public:
//Eigenschaften
  __property String Name={read =GetName}; // der Vollständige Datename der Arbeitsmappe
  __property int Index ={read =GetIndex}; // gib den Index in der MLExcel- Instanz zurück
  __property TMLWorksheet* Sheets [int Index]= {read = GetFromWorksheets}; // Zugriff auf die Tabellen in der Arbeitsmappe
  __property int WorksheetCount = {read = GetWorksheetCount};    // Anzahl der Tabellen in der Arbeitsmappe
  __property TStringList* WorksheetNames={read=GetWorksheetNames}; // Stringliste derNamen aller Tabellen in der Arbeitsmappe

    __property Variant AsVariant={read=var_Book}; // die Arbeitsmappe als Variant (nur verwenden wenn unbeding Notwendig!)

    __property bool Connect ={read=GetConnect};   // ist true, wenn eine Verbindung mit einer Arbeitsmappe in Excel besteht
  __property TMLExcel* Parent={read=FParentExcel};  // die Excelinstanz, inder sich die Arbeitsmappe befindet
  //Methoden
         __fastcall TMLWorkbook(TMLExcel* excel, Variant book);
         __fastcall ~TMLWorkbook();

   void __fastcall UpdateSheetList();  // Aktualisiert die Instanz. Notwendig, wenn zum Beispiel jemand in Excel etwas manuell ändert
   int __fastcall IndexOfWorksheets(String AName); // Gibt den Index der Tabelle anhand seines Namen zurück
                                                   // gibt  -1 zurück wenn keine Tabelle mit den Namen existiert

   void __fastcall Activate();//macht diese Arbeitsmappe zu aktuellen Arbeitsmappe in Excel
   bool SaveAs(String FileName);// Arbeitsmappe speichern als..
   bool Save();                 // Arbeitsmappe speichern

   void Add();  // neue Tabelle hinzufügen
   bool Add(String Name); // neue Tabelle hinzufügen und gleich einen Namen vergeben

};
//----------------------------------------------------------------------------
//                   TMLExcel
//----------------------------------------------------------------------------
class  TMLExcel
{
private:
   //Variablen
   TList * FWorkbooks;
   bool FConnect;
   Variant var_Excel;
   TStringList * FBookNames;
   bool FVisible;
   bool FClose;

   //Methoden
   int GetWorkbookCount();
   TStringList*__fastcall GetWorkbookNames();
   void __fastcall SetVisible(bool temp);
   Variant __fastcall GetBooks();
   bool __fastcall GetConnect();
   void __fastcall SetConnect(bool temp);
   TMLWorkbook* __fastcall GetFromWorkbooks(int Index);

protected:

public:
//Eigenschaften
   __property TStringList* WorkbookNames={read=GetWorkbookNames}; // Stringliste mit den vollständigen Dateinamen der Arbeitsmappen in der Excelinstanz
   __property int WorkbookCount={read=GetWorkbookCount};          // Anzahl der Arbeitsmappen in Excel
   __property TMLWorkbook* Books[int Index]={read=GetFromWorkbooks}; // Zugriffsmöglichkeit auf die einzelnen Arbeitsmappen
   __property bool Visible ={read=FVisible,write=SetVisible};        // Excel auf den Bildschirm anzeigen oder verbergen
   __property bool Connect = {read=GetConnect, write=SetConnect};    // mit Excel verbinden oder´die bestehende Verbindung trennen und Excel schliessen.
   __property Variant AsVariant={read=var_Excel};                   // Die Excelinstanz als Variant
   __property bool CloseExcelOnTerminate={read=FClose,write=FClose}; //wenn true wird im Destruktor Excel geschlossen
//Methoden
         __fastcall TMLExcel();
         __fastcall ~TMLExcel();

   void __fastcall UpdateBookList();  // Aktualisiert die Instance. Nur notwendig, wenn in Excel manuel Änderungen durchgeführt wurden
   int __fastcall IndexOfWorkbooks(String AName); // gibt den Index einer Arbeitsmappe anhand seines vollständigen(!) Dateinamens zurück

   bool OpenWorkbook(AnsiString BookName); // Arbeitsmappe öffnen ( BookName == Vollständiger DateiName der Arbeitsmappe)
   bool CloseWorkbook(AnsiString BookName); // Arbeitsmappe schliesen ( BookName == Vollständiger DateiName der Arbeitsmappe)

   bool SaveWorkbook(AnsiString BookName);  // Arbeitsmappe speichern ( BookName == Vollständiger DateiName der Arbeitsmappe)
   bool SaveWorkbookAs(AnsiString BookName, String FileName);// Arbeitsmappe speichern ( BookName && FileName== Vollständiger DateiName der Arbeitsmappe)
   bool SaveWorkbookAs(int Index, String FileName); // Arbeitsmappe speichern(Index ist der Index der Arbietsmappe inerhalb dieser Instanz && BookName == Vollständiger DateiName der Arbeitsmappe)

   void NewWorkbook();  //neue Arbeitsmappe anlegen
   bool NewWorkbook(String FileName, bool Overwrite);// neue Arbeitsmappe anlegen und speichern unter FileName
};
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------
#pragma hdrstop
#include "MLExcel.h"
#include <Dialogs.hpp>
#include "SysUtils.hpp"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//--------------------------------------------------------------------------
//############################################################################
//----------------------------------------------------------------------------
//                   Class TMLWorksheet
//----------------------------------------------------------------------------
__fastcall TMLWorksheet::TMLWorksheet(TMLWorkbook* AWorkbook,Variant ASheet)
   :FParentWorkbook(AWorkbook),var_Sheet(ASheet)
{
FMaxRows=200;
FMaxCols=50;
FRow=new TStringList;
FRow->Clear();
FCol=new TStringList;
FCol->Clear();
}
__fastcall TMLWorksheet::~TMLWorksheet()
{
if(FRow) delete FRow;
if(FCol) delete FCol;
}
//----------------------------------------------------------------------------
void __fastcall TMLWorksheet::Activate()
{
var_Sheet.OleFunction("Activate");
}
//----------------------------------------------------------------------------
//properties getters and setters
//----------------------------------------------------------------------------
int __fastcall TMLWorksheet::GetIndex()
{
return FParentWorkbook->WorksheetNames->IndexOf(Name);
}
//----------------------------------------------------------------------------
String __fastcall TMLWorksheet::GetName()
{
   return var_Sheet.OlePropertyGet("Name");
}
//----------------------------------------------------------------------------
void __fastcall TMLWorksheet::SetName(String AName)
{
  if(AName !="" && FParentWorkbook->IndexOfWorksheets(Name)<0)
            var_Sheet.OlePropertySet("Name",AName.c_str());
}
//----------------------------------------------------------------------------
int __fastcall TMLWorksheet::GetColCount()
{
 return var_Sheet.OlePropertyGet("Columns").OlePropertyGet("Count");
}
//----------------------------------------------------------------------------
int __fastcall TMLWorksheet::GetRowCount()
{
 return var_Sheet.OlePropertyGet("Rows").OlePropertyGet("Count");
}
//----------------------------------------------------------------------------
TStringList* __fastcall TMLWorksheet::GetCols(int Index)
{
if(!FCol)FCol=new TStringList();
FCol->Clear();
for (int i=1;i<FMaxRows;i++)
      {
         FCol->Add(var_Sheet.OlePropertyGet("Cells",i,Index+1).OlePropertyGet("Value"));

      }
return FCol;
}
//----------------------------------------------------------------------------
TStringList* __fastcall TMLWorksheet::GetRows(int Index)
{
if(!FRow)FRow=new TStringList();
FRow->Clear();
for (int i=1;i<FMaxCols;i++)
      {
         FRow->Add(var_Sheet.OlePropertyGet("Cells",Index+1,i).OlePropertyGet("Value"));
      }
return FRow;

}
//----------------------------------------------------------------------------
String __fastcall TMLWorksheet::GetCellString(int Col, int Row)
{
   return var_Sheet.OlePropertyGet("Cells",Col+1,Row+1).OlePropertyGet("Value");
}
//----------------------------------------------------------------------------
void __fastcall TMLWorksheet::SetCellString(int Col, int Row, String Text)
{
   var_Sheet.OlePropertyGet("Cells",Col+1,Row+1).OlePropertySet("Value",Text.c_str());
}
//---------------------------------------------------------------------------
void __fastcall TMLWorksheet::SetCellString_Range(String Range,String Text)
{
   return var_Sheet.OlePropertyGet("Range",Range.c_str()).OlePropertySet("Value",Text.c_str());
}
//---------------------------------------------------------------------------

//############################################################################
//----------------------------------------------------------------------------
//                   Class TMLWorkbook
//----------------------------------------------------------------------------
__fastcall TMLWorkbook::TMLWorkbook(TMLExcel* excel, Variant book)
                :FParentExcel(excel),var_Book(book)
{
      FSheetNames=new TStringList;
      FWorksheets=new TList;
      FWorksheets->Clear();
}
//----------------------------------------------------------------------------
__fastcall TMLWorkbook::~TMLWorkbook()
{

   delete FSheetNames;
   FWorksheets->Clear();
   delete FWorksheets;
}
//----------------------------------------------------------------------------
void  TMLWorkbook::Add()
{
   var_Book.OlePropertyGet("Sheets").OleFunction("Add");
   UpdateSheetList();
}
//----------------------------------------------------------------------------
bool TMLWorkbook::Add(String Name)
{
   var_Book.OlePropertyGet("Sheets").OleFunction("Add");
   UpdateSheetList();
   var_Book.OlePropertyGet("Sheets",WorksheetCount).OlePropertySet("Name",Name.c_str());
   UpdateSheetList();
}
//-----------------------------------------------------------------------------
bool TMLWorkbook::SaveAs(String FileName)
{
try
   {
    var_Book.OleFunction("SaveAs",FileName.c_str());
    return true;
   }
catch(...)
   {
    return false;
   }
}
//-----------------------------------------------------------------------------
bool TMLWorkbook::Save()
{
try
   {
    var_Book.OleFunction("Save");
    return true;
   }
catch(...)
   {
    return false;
   }
}
//----------------------------------------------------------------------------
void __fastcall TMLWorkbook::Activate()
{
var_Book.OleFunction("Activate");
}
//-----------------------------------------------------------------------------
void __fastcall TMLWorkbook::UpdateSheetList()
{
FSheetNames->Clear();
if(Connect)
   {
   if(!(WorksheetCount ==FSheetNames->Count || WorksheetCount ==FWorksheets->Count ))
   {
   FSheetNames->Clear();
   for( int i=FWorksheets->Count-1;i>=0;i--)
        {
           TMLWorksheet* sheet=  reinterpret_cast <TMLWorksheet*>( FWorksheets->Items[i]);
           if(sheet) delete sheet;
        }  
   FWorksheets->Clear();

   if(WorksheetCount>0)
      {
         for( int i=1;i<=WorksheetCount;i++)
            {
              TMLWorksheet * book=new TMLWorksheet(this,(Variant)var_Book.OlePropertyGet("WorkSheets",i));
              FWorksheets->Add((void*)book);

              FSheetNames->Add(var_Book.OlePropertyGet("Worksheets",i).OlePropertyGet("Name"));
            }
      }
     // ShowMessage(FSheetNames->Text);
   }
   }
}
//----------------------------------------------------------------------------
int __fastcall TMLWorkbook::IndexOfWorksheets(String AName)
{
   return WorksheetNames->IndexOf(AName);
}

//----------------------------------------------------------------------------
//properties getters and setters
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
String __fastcall TMLWorkbook::GetName()
{
   if(Connect)
   return var_Book.OlePropertyGet("FullName");
else return "";
}
//----------------------------------------------------------------------------
bool __fastcall TMLWorkbook::GetConnect()
{
return !VarIsEmpty(var_Book);
}
//----------------------------------------------------------------------------
int __fastcall TMLWorkbook::GetWorksheetCount()
{
   if(Connect)
      return var_Book.OlePropertyGet("Worksheets").OlePropertyGet("Count");
   else
      return 0;
}
//----------------------------------------------------------------------------
TStringList*__fastcall TMLWorkbook::GetWorksheetNames()
{
   UpdateSheetList();
   return FSheetNames;
}
//----------------------------------------------------------------------------
int __fastcall TMLWorkbook::GetIndex()
{
return FParentExcel->WorkbookNames->IndexOf(Name);
}
//-----------------------------------------------------------------------------
TMLWorksheet* __fastcall TMLWorkbook::GetFromWorksheets(int Index)
{
   UpdateSheetList();

if( Index >=0 && Index <WorksheetCount)
   {
     return (TMLWorksheet*) FWorksheets->Items[Index];
   }
else return NULL;

}
//----------------------------------------------------------------------------
//#############################################################################
//----------------------------------------------------------------------------
//                   TMLExcel
//----------------------------------------------------------------------------
// public methods
__fastcall TMLExcel::TMLExcel()
{
 try
 {
   FClose=true;
   FVisible=false;
   FBookNames=new TStringList;
   FBookNames->Clear();
   var_Excel=CreateOleObject("Excel.Application");
   // Excelinstanz zu Kontrollzwecken sichtbar machen
   var_Excel.OlePropertySet("Visible", FVisible);
   //var_Books = var_Excel.OlePropertyGet("Workbooks");
   FWorkbooks=new TList;
   FWorkbooks->Clear();
   UpdateBookList();
 }
 catch (...)
 {

 }
}
//----------------------------------------------------------------------------
__fastcall TMLExcel::~TMLExcel()
{
delete FBookNames;
FWorkbooks->Clear();
delete FWorkbooks;
if(Connect && FClose) var_Excel.OleFunction("Quit");
}
//----------------------------------------------------------------------------
bool TMLExcel::OpenWorkbook(AnsiString BookName)
{
  try
  {
   if(Connect && (IndexOfWorkbooks(BookName)+1)<=0)
   {
    Procedure Open("Open");
    var_Excel.OlePropertyGet("Workbooks").Exec(Open << BookName);
    UpdateBookList();
    return true;
    }
   else return false;
  }
  catch (...)
  {
    return false;
  }
}

//----------------------------------------------------------------------------
bool TMLExcel::CloseWorkbook(AnsiString BookName)
{
  try
  {
   int temp=IndexOfWorkbooks(BookName);
   if(Connect && temp)
       var_Excel.OlePropertyGet("Workbooks",temp).OleProcedure("Close");
   else
      return false;

   UpdateBookList();
   return true;
  }
  catch (...)
  {
     return false;
  }
}
//----------------------------------------------------------------------------
bool TMLExcel::SaveWorkbook(AnsiString BookName)
{
  try
  {
   int temp=IndexOfWorkbooks(BookName);
   if(Connect && ++temp)
       var_Excel.OlePropertyGet("Workbooks",temp).OleProcedure("Save");
   else
      return false;

   UpdateBookList();
   return true;
  }
  catch (...)
  {
     return false;
  }
}
//----------------------------------------------------------------------------
bool TMLExcel::SaveWorkbookAs(AnsiString BookName, String FileName)
{
  try
  {
   int temp=IndexOfWorkbooks(BookName);
   if(Connect && ++temp)
       var_Excel.OlePropertyGet("Workbooks",temp).OleProcedure("SaveAs",(Variant) FileName);
   else
      return false;

   UpdateBookList();
   return true;
  }
  catch (...)
  {
     return false;
  }
}
//----------------------------------------------------------------------------
bool TMLExcel::SaveWorkbookAs(int Index, String FileName)
{
  try
  {
  Index++;
   if(Connect && Index && Index <=WorkbookCount)
       var_Excel.OlePropertyGet("Workbooks",Index).OleFunction("SaveAs",FileName.c_str());
   else
      return false;

   UpdateBookList();
   return true;
  }
  catch (...)
  {
     return false;
  }
}

//----------------------------------------------------------------------------
void __fastcall TMLExcel::UpdateBookList()
{
   if(!(WorkbookCount ==FBookNames->Count || WorkbookCount ==FWorkbooks->Count ))
   {
   FBookNames->Clear();
   for( int i=FWorkbooks->Count-1;i>=0;i--)
        {
           TMLWorkbook* book=  reinterpret_cast <TMLWorkbook*>( FWorkbooks->Items[i]);
           if(book) delete book;
        }  
   FWorkbooks->Clear();
   if(Connect && WorkbookCount>0 )
      {
         for( int i=1;i<=WorkbookCount;i++)
            {
              FBookNames->Add(var_Excel.OlePropertyGet("Workbooks",i).OlePropertyGet("FullName"));
              TMLWorkbook * book=new TMLWorkbook(this,(Variant)var_Excel.OlePropertyGet("Workbooks",i));
              FWorkbooks->Add((void*)book);
            }
      }
   }
      //ShowMessage(FBookNames->Text);
}
//----------------------------------------------------------------------------
int __fastcall TMLExcel::IndexOfWorkbooks(String AName)
{
   return WorkbookNames->IndexOf(AName);
}
//----------------------------------------------------------------------------
void TMLExcel::NewWorkbook()
{
if( Connect)
   {
      var_Excel.OlePropertyGet("WorkBooks").OleFunction("Add");
      UpdateBookList();
   }
}
//----------------------------------------------------------------------------
bool TMLExcel::NewWorkbook(String FileName, bool Overwrite)
{
if (Connect && (FileExists(FileName) && Overwrite) || !FileExists(FileName))
   {
      try
         {
            if(IndexOfWorkbooks(FileName)<0)
               {
                  var_Excel.OleFunction("Add");
                  UpdateBookList();
                  var_Excel.OlePropertyGet("Woorkbooks",WorkbookCount).OleFunction("SaveAs",FileName.c_str());
                  UpdateBookList();
                  return true;
               }
            else
               {
                  CloseWorkbook(FileName);
                  var_Excel.OleFunction("Add");
                  UpdateBookList();
                  var_Excel.OlePropertyGet("Woorkbooks",WorkbookCount).OleFunction("SaveAs",FileName.c_str());
                  UpdateBookList();
                  return true;
               }
         }
      catch(...)
         {
         return false;

         }
   }
else
   return false;
}

//----------------------------------------------------------------------------
//properties getters and setters
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool __fastcall TMLExcel::GetConnect()
{
   return !VarIsEmpty(var_Excel);
}
//----------------------------------------------------------------------------
void __fastcall TMLExcel::SetConnect(bool temp)
{
if(!temp)var_Excel.OleFunction("Quit");
else
   {
   if(VarIsEmpty(var_Excel))
      {
        try
          {
            FVisible=false;
            FBookNames=new TStringList;
            FBookNames->Clear();
            var_Excel=CreateOleObject("Excel.Application");
            var_Excel.OlePropertySet("Visible", FVisible);
            FWorkbooks->Clear();
            UpdateBookList();
          }
         catch (...)
            {

            }
      }
   }
}
//----------------------------------------------------------------------------
int TMLExcel::GetWorkbookCount()
{
  if(!Connect)
   return 0;
  else
   return var_Excel.OlePropertyGet("Workbooks").OlePropertyGet("Count");
}

//----------------------------------------------------------------------------
TStringList*__fastcall TMLExcel::GetWorkbookNames()
{
   UpdateBookList();
   return FBookNames;
}
//----------------------------------------------------------------------------
void __fastcall TMLExcel::SetVisible(bool temp)
{
   if(!Connect)
          FVisible=false;
   else
      FVisible=temp;
   var_Excel.OlePropertySet("Visible", FVisible);
}
//----------------------------------------------------------------------------
TMLWorkbook* __fastcall TMLExcel::GetFromWorkbooks(int Index)
{
   UpdateBookList();
   if(WorkbookCount &&  Index >=0 && Index <WorkbookCount)
   {
     return (TMLWorkbook*) FWorkbooks->Items[Index];
   }
   else return NULL;
}
//----------------------------------------------------------------------------
Variant __fastcall TMLExcel::GetBooks()
{
   return var_Excel.OlePropertyGet("Workbooks");
}
//----------------------------------------------------------------------------
    0
  • A

    Beispielprojekt:

    //---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "MLExcel.h"
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:
   TButton *Button1;
   TButton *Button2;
   TEdit *Edit1;
   void __fastcall Button1Click(TObject *Sender);
   void __fastcall Button2Click(TObject *Sender);
private:
public:
      __fastcall TForm1(TComponent* Owner);
      __fastcall ~TForm1();
   TMLExcel * Excel;
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
Excel =new TMLExcel;
Excel->Visible=true;
}
//---------------------------------------------------------------------------
__fastcall TForm1::~TForm1()
{
delete Excel;
}
//----------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Excel->OpenWorkbook(Edit1->Text);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
ShowMessage(Excel->Books[0]->Sheets[0]->CellString[0][0]);   
}
//---------------------------------------------------------------------------
    0
Anmelden zum Antworten