Änderungen im ExcelWrapper aus der FAQ

[Braunstein]

Hallo,

Ich hatte im Laufe der Zeit ein paar Änderungen (und Bugfixes) in der in der FAQ genannten ExcelWrapper-Klasse von AndreasW gemacht.
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39259.html
Ich stelle dir hier mal zur Diskussion (auf Wunsch von Jansen). Es ist natürlich ein wenig viel Code.
Header

//---------------------------------------------------------------------------
#ifndef Lib_ExcelClassesH
#define Lib_ExcelClassesH

#include <Extctrls.hpp>
#include <vector>

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

enum TMsoShapeType {
  msoShapeTypeMixed = -2, msoAutoShape = 1, msoCallout = 2, msoChart = 3,
  msoComment = 4,  msoFreeform = 5, msoGroup = 6, msoEmbeddedOLEObject = 7,
  msoFormControl = 8,msoLine = 9, msoLinkedOLEObject = 10, msoLinkedPicture = 11,
  msoOLEControlObject = 12, msoPicture = 13, msoPlaceholder = 14, msoTextEffect = 15,
  msoMedia = 16, msoTextBox = 17,  msoScriptAnchor = 18, msoTable = 19,
  msoCanvas = 20,msoDiagram = 21, msoInk = 22, msoInkComment = 23 };

class TMLWorkbook;

class  TMLExcel
{
private:
   //Variablen
   typedef std::vector<TMLWorkbook*> WBookVect;
   typedef std::vector<TMLWorkbook*>::iterator WBookIter;

   WBookVect FWorkbooks;
   bool FConnect;
   Variant var_Excel;
   std::vector<AnsiString> FBookNames;
   bool FVisible;
   bool FClose;

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

protected:

public:
//Eigenschaften
   std::vector<AnsiString> __fastcall GetWorkbookNames();
   __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(const AnsiString& AName); // gibt den Index einer Arbeitsmappe anhand seines vollständigen(!) Dateinamens zurück

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

   bool SaveWorkbook(const AnsiString& BookName);  // Arbeitsmappe speichern ( BookName == Vollständiger DateiName der Arbeitsmappe)
   bool SaveWorkbookAs(const AnsiString& BookName, const AnsiString& FileName);// Arbeitsmappe speichern ( BookName && FileName== Vollständiger DateiName der Arbeitsmappe)
   bool SaveWorkbookAs(int Index, const AnsiString& 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(const AnsiString& FileName, bool Overwrite);// neue Arbeitsmappe anlegen und speichern unter FileName
};
//----------------------------------------------------------------------------
//                   Class TMLWorkbook
//----------------------------------------------------------------------------
class TMLWorksheet;

class TMLWorkbook
{
public:
   TMLWorkbook(TMLExcel* excel, const Variant& book) : FParentExcel(excel),var_Book(book) {}
private:
//Variablen
   typedef std::vector<TMLWorksheet> WSheetVect;
   typedef std::vector<TMLWorksheet>::iterator WSheetIter;

   WSheetVect FWorksheets;
   Variant var_Book;
   Variant var_Sheet;
   std::vector<AnsiString> FSheetNames;
   int FIndex;
   TMLExcel* FParentExcel;

//Methoden
   int __fastcall GetWorksheetCount();
   String __fastcall GetName();
   std::vector<AnsiString> __fastcall GetWorksheetNames();
   int __fastcall GetIndex();
   bool __fastcall GetConnect();
   TMLWorksheet __fastcall GetFromWorksheets(int Index);
   AnsiString  __fastcall GetAuthor();

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 std::vector<AnsiString> WorksheetNames={read=GetWorksheetNames}; // vector der Namen 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
  __property AnsiString Author={read = GetAuthor};  // gibt den Autoren der Datei zurück
  //Methoden

   void __fastcall UpdateSheetList();  // Aktualisiert die Instanz. Notwendig, wenn zum Beispiel jemand in Excel etwas manuell ändert
   int __fastcall IndexOfWorksheets(const AnsiString& 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(const AnsiString& FileName);// Arbeitsmappe speichern als..
   bool Save();                 // Arbeitsmappe speichern

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

};
//----------------------------------------------------------------------------
//                   Class TMLWorksheet
//----------------------------------------------------------------------------
class TMLWorksheet
{
public:
   TMLWorksheet(TMLWorkbook* AWorkbook,const Variant& ASheet)
              : MaxRows(2000), MaxCols(200), var_Sheet(ASheet), FParentWorkbook(AWorkbook) {}
   int MaxRows;
   int MaxCols;
   int __fastcall GetIndex();
   String __fastcall GetName();
   void __fastcall SetName(const AnsiString& AName);
   int __fastcall GetColCount();
   int __fastcall GetRowCount();
   int __fastcall GetShapesCount();
   std::vector<AnsiString> __fastcall GetCols(int Index);
   std::vector<AnsiString> __fastcall GetRows(int Index);
   String __fastcall GetCellString(int Col, int Row);
   void __fastcall SetCellString(int Col, int Row, const AnsiString& Text);
   String __fastcall GetCellString_Range(const AnsiString& Range);
   void __fastcall SetCellString_Range(const AnsiString& Range, const AnsiString& Text);
   AnsiString __fastcall GetShapeName( int Num);
   TMsoShapeType __fastcall GetShapeType( int Num);
   AnsiString __fastcall GetShapeTypeDescript( int Num);
   Variant GetSheetAsVariant() { return var_Sheet; }
   TMLWorkbook* GetParentWorkbook() { return FParentWorkbook; }
private:
//Variablen
   Variant var_Sheet;
   TMLWorkbook *FParentWorkbook;
//Methoden

protected:

public:

//Methoden
   void __fastcall Activate(); // macht die diese Tabelle zur aktuellen Tabelle in der Arbeitsmappe
   void __fastcall Protect(const AnsiString& Passwd);

   void __fastcall CopyShapePicture( int Num);
   bool __fastcall FillMetafileFromShape( int Num, TMetafile *ameta);
   bool __fastcall FillImageFromShape( int Num, TImage *aimage);
};
//---------------------------------------------------------------------------
#endif

cpp

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//#include <vcl.h>
#pragma hdrstop

#include <comobj.hpp>   // für OLE
#include <utilcls.h>    // für OLE
#include <clipbrd.hpp>
#include "Lib_ExcelClasses.h"
#include <algorithm>

//----------------------------------------------------------------------------
//                   Class TMLWorksheet
//----------------------------------------------------------------------------
void __fastcall TMLWorksheet::Activate()
{
    var_Sheet.OleFunction("Activate");
}
//----------------------------------------------------------------------------
//properties getters and setters
//----------------------------------------------------------------------------
int __fastcall TMLWorksheet::GetIndex()
{
    return FParentWorkbook->IndexOfWorksheets(GetName());
}
//----------------------------------------------------------------------------
String __fastcall TMLWorksheet::GetName()
{
    return var_Sheet.OlePropertyGet("Name");
}
//----------------------------------------------------------------------------
void __fastcall TMLWorksheet::SetName(const AnsiString& AName)
{
    if(AName !="" && GetIndex() < 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");
}
//----------------------------------------------------------------------------

std::vector<AnsiString> __fastcall TMLWorksheet::GetCols(int Index)
{
  std::vector<AnsiString> FCol;
  for (int i=1;i<MaxCols;i++)
  {
     FCol.push_back(var_Sheet.OlePropertyGet("Cells",Index+1,i).OlePropertyGet("Value"));
  }
  return FCol;
}
//----------------------------------------------------------------------------
std::vector<AnsiString> __fastcall TMLWorksheet::GetRows(int Index)
{
  std::vector<AnsiString> FRow;
  for (int i=1;i<MaxRows;i++)
  {
     FRow.push_back(var_Sheet.OlePropertyGet("Cells",i,Index+1).OlePropertyGet("Value"));
  }
  return FRow;
}
//----------------------------------------------------------------------------
String __fastcall TMLWorksheet::GetCellString(int Col, int Row)
{
   return var_Sheet.OlePropertyGet("Cells",Row,Col).OlePropertyGet("Value");
}
//----------------------------------------------------------------------------
void __fastcall TMLWorksheet::SetCellString(int Col, int Row, AnsiString Text)
{
   var_Sheet.OlePropertyGet("Cells",Row,Col).OlePropertySet("Value",Text.c_str());
}
//----------------------------------------------------------------------------
// Funktionen für Shapes

int __fastcall TMLWorksheet::GetShapesCount()
{
   return var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Count");
}
//----------------------------------------------------------------------------

AnsiString __fastcall TMLWorksheet::GetShapeName( int Num)
{
//   if( Num <= var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Count"))
   {
        Variant Shape = var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Range",Num);
        return Shape.OlePropertyGet("Name");
   }
//   return "";
}
//----------------------------------------------------------------------------

TMsoShapeType __fastcall TMLWorksheet::GetShapeType( int Num)
{
//   if( Num <= var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Count"))
   {
        Variant Shape = var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Range",Num);
        return static_cast<TMsoShapeType>(static_cast<int>(Shape.OlePropertyGet("Type")));
   }
//   return "";
}
//----------------------------------------------------------------------------

AnsiString __fastcall TMLWorksheet::GetShapeTypeDescript( int Num)
{
    Variant Shape = var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Range",Num);
    TMsoShapeType type = static_cast<TMsoShapeType>(static_cast<int>(Shape.OlePropertyGet("Type")));
    AnsiString result;
    switch(type)
    {
        case msoAutoShape         : result = "AutoShape"; break;
        case msoCallout           : result = "Callout"; break;
        case msoCanvas            : result = "Canvas"; break;
        case msoChart             : result = "Chart"; break;
        case msoComment           : result = "Comment"; break;
        case msoDiagram           : result = "Diagram"; break;
        case msoEmbeddedOLEObject : result = "EmbeddedOLEObject"; break;
        case msoFormControl       : result = "FormControl"; break;
        case msoFreeform          : result = "Freeform"; break;
        case msoGroup             : result = "Group"; break;
        case msoInk               : result = "Ink"; break;
        case msoInkComment        : result = "InkComment"; break;
        case msoLine              : result = "Line"; break;
        case msoLinkedOLEObject   : result = "LinkedOLEObject"; break;
        case msoLinkedPicture     : result = "LinkedPicture"; break;
        case msoMedia             : result = "Media"; break;
        case msoOLEControlObject  : result = "OLEControlObject"; break;
        case msoPicture           : result = "Picture"; break;
        case msoPlaceholder       : result = "Placeholder"; break;
        case msoScriptAnchor      : result = "ScriptAnchor"; break;
        case msoShapeTypeMixed    : result = "ShapeTypeMixed"; break;
        case msoTable             : result = "Table"; break;
        case msoTextBox           : result = "TextBox"; break;
        case msoTextEffect        : result = "TextEffect"; break;
        default :  result = "unknown"; break;
    }
    return result;
}
//----------------------------------------------------------------------------

void __fastcall TMLWorksheet::CopyShapePicture( int Num)
{
    Variant Shape = var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Range",Num);
    Shape.OleFunction("Select");
    Variant Selection = FParentWorkbook->Parent->AsVariant.OlePropertyGet("Selection");
    Selection.OleProcedure("CopyPicture");
}
//----------------------------------------------------------------------------

bool __fastcall TMLWorksheet::FillMetafileFromShape( int Num, TMetafile *ameta)
{
    Variant Shape = var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Range",Num);
    Shape.OleFunction("Select");
    Variant Selection = FParentWorkbook->Parent->AsVariant.OlePropertyGet("Selection");
    Selection.OleProcedure("CopyPicture");
    if( Clipboard()->HasFormat(CF_ENHMETAFILE))
    {
        if( ameta == NULL ) return false;
        ameta->Handle = Clipboard()->GetAsHandle(CF_ENHMETAFILE);
        return true;
    } else return false;
}
//----------------------------------------------------------------------------

bool __fastcall TMLWorksheet::FillImageFromShape( int Num, TImage *aimage)
{
    if( aimage == NULL ) return false;
    Variant Shape = var_Sheet.OlePropertyGet("Shapes").OlePropertyGet("Range",Num);
    Shape.OleFunction("Select");
    Variant Selection = FParentWorkbook->Parent->AsVariant.OlePropertyGet("Selection");
    Selection.OleProcedure("CopyPicture");
    if( Clipboard()->HasFormat(CF_ENHMETAFILE))
    {
       TMetafile *ameta = new TMetafile;
       ameta->Handle = Clipboard()->GetAsHandle(CF_ENHMETAFILE);
       try
       {
         aimage->Picture = NULL;
         aimage->Picture->Bitmap->Width = ameta->Width;
         aimage->Picture->Bitmap->Height = ameta->Height;
         aimage->Picture->Bitmap->Canvas->Draw(0, 0, ameta);
       }
       __finally
       {
         ameta->Handle = NULL;
         delete ameta;
       }
       return true;
    } else return false;
}
//----------------------------------------------------------------------------

// sonstige Funktionen
void __fastcall TMLWorksheet::Protect(const AnsiString& Passwd)
{
   var_Sheet.OleProcedure("Protect",Passwd.c_str(),true,true,true);
}
//----------------------------------------------------------------------------
String __fastcall TMLWorksheet::GetCellString_Range(const AnsiString& Range)
{
   /*Variant range=var_Sheet.OlePropertyGet("Range",Range.c_str()).OlePropertyGet("Value");
   if(range.OlePropertyGet("Count")=(Variant)1)
      return range.OlePropertyGet("Value");
   else return"toomucch";   */
   return "";
}
//---------------------------------------------------------------------------
void __fastcall TMLWorksheet::SetCellString_Range(const AnsiString& Range,const AnsiString& Text)
{
   var_Sheet.OlePropertyGet("Range",Range.c_str()).OlePropertySet("Value",Text.c_str());
}
//---------------------------------------------------------------------------

//############################################################################
//----------------------------------------------------------------------------
//                   Class TMLWorkbook
//----------------------------------------------------------------------------
void  TMLWorkbook::Add()
{
   var_Book.OlePropertyGet("Sheets").OleFunction("Add");
   UpdateSheetList();
}
//----------------------------------------------------------------------------
bool TMLWorkbook::Add(const AnsiString& Name)
{
   var_Book.OlePropertyGet("Sheets").OleFunction("Add");
   UpdateSheetList();
   var_Book.OlePropertyGet("Sheets",WorksheetCount).OlePropertySet("Name",Name.c_str());
   UpdateSheetList();
   return true;
}
//-----------------------------------------------------------------------------
bool TMLWorkbook::SaveAs(const AnsiString& 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()
{
   if(Connect)
   {
     int count = GetWorksheetCount();
     FWorksheets.clear();
     FSheetNames.clear();
     if(count > 0)
     {
         for( int i=1;i<=WorksheetCount;i++)
         {
           FWorksheets.push_back(TMLWorksheet(this,(Variant)var_Book.OlePropertyGet("WorkSheets",i)));
           FSheetNames.push_back(var_Book.OlePropertyGet("Worksheets",i).OlePropertyGet("Name"));
         }
     }
   }
}
//----------------------------------------------------------------------------
int __fastcall TMLWorkbook::IndexOfWorksheets(const AnsiString& AName)
{
   std::vector<AnsiString>::iterator it = std::find(FSheetNames.begin(), FSheetNames.end(), AName);
   if( it == FSheetNames.end()) return -1;
   return it - FSheetNames.begin();
}

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

//----------------------------------------------------------------------------
String __fastcall TMLWorkbook::GetName()
{
   if(Connect) return var_Book.OlePropertyGet("FullName");
   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;
}
//----------------------------------------------------------------------------
std::vector<AnsiString> __fastcall TMLWorkbook::GetWorksheetNames()
{
   return FSheetNames;
}
//----------------------------------------------------------------------------
int __fastcall TMLWorkbook::GetIndex()
{
	std::vector<AnsiString> names(FParentExcel->GetWorkbookNames());
	std::vector<AnsiString>::iterator pos = std::find(names.begin(), names.end(), Name);
	if( pos == names.end()) return -1;
	return pos - names.begin();
}
//-----------------------------------------------------------------------------
TMLWorksheet& __fastcall TMLWorkbook::GetFromWorksheets(int Index)
{
   UpdateSheetList();
   if( Index >=0 && Index <WorksheetCount)
   {
     return FWorksheets[Index];
   } else throw std::out_of_range("Index out of range");
}
//-----------------------------------------------------------------------------

AnsiString __fastcall TMLWorkbook::GetAuthor()
{
   AnsiString autor = var_Book.OlePropertyGet("Author");
   return autor;
}
//----------------------------------------------------------------------------
//#############################################################################
//----------------------------------------------------------------------------
//                   TMLExcel
//----------------------------------------------------------------------------
// public methods
__fastcall TMLExcel::TMLExcel() : FClose(true), FVisible(false)
{
 try
 {
   var_Excel=CreateOleObject("Excel.Application");
   // Excelinstanz zu Kontrollzwecken sichtbar machen
   var_Excel.OlePropertySet("Visible", FVisible);
   //var_Books = var_Excel.OlePropertyGet("Workbooks");
   UpdateBookList();
 }
 catch (...)
 {

 }
}
//----------------------------------------------------------------------------
__fastcall TMLExcel::~TMLExcel()
{
  for( WBookIter it = FWorkbooks.begin(); it!=FWorkbooks.end(); ++it)
       delete *it;
//  FWorkbooks.clear();
  if(Connect && FClose) var_Excel.OleFunction("Quit");
}
//----------------------------------------------------------------------------
bool TMLExcel::OpenWorkbook(const AnsiString& BookName)
{
  try
  {
   if( !Connect ) return false;
   int index = IndexOfWorkbooks(BookName);
   if(index > -1) return true;
   Procedure Open("Open");
//   var_Excel.OlePropertyGet("Workbooks").Exec(Open << BookName);
//   Variant wbook = var_Excel.OlePropertyGet("Workbooks");
//   wbook.Exec(Open << book);
   var_Excel.OlePropertyGet("Workbooks").OlePropertyGet("Open", BookName.c_str());
   UpdateBookList();
   return true;                                                                
  }
  catch (...)
  {
    return false;
  }
}

//----------------------------------------------------------------------------
bool TMLExcel::CloseWorkbook(const 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::CloseAllWorkbooks()
{
  try
  {
   if(Connect)
   {
       int count = GetWorkbookCount();
       for( int i=1; i<=count; i++) var_Excel.OlePropertyGet("Workbooks",i).OleProcedure("Close");
   }
   else
      return false;

   UpdateBookList();
   return true;
  }
  catch (...)
  {
     return false;
  }
}
//----------------------------------------------------------------------------
bool TMLExcel::SaveWorkbook(const 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(const AnsiString& BookName, const AnsiString& 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, const AnsiString& 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()
{
   int count = GetWorkbookCount();
   for( WBookIter it = FWorkbooks.begin(); it!=FWorkbooks.end(); ++it)
       delete *it;
   FWorkbooks.clear();
   FBookNames.clear();
   if(Connect && count > 0)
   {
	   for( int i=1;i<=count;i++)
	   {
		 FBookNames.push_back(var_Excel.OlePropertyGet("Workbooks",i).OlePropertyGet("FullName"));
         FWorkbooks.push_back(new TMLWorkbook(this,(Variant)var_Excel.OlePropertyGet("Workbooks",i)));
       }
   }
}
//----------------------------------------------------------------------------
int __fastcall TMLExcel::IndexOfWorkbooks(const AnsiString& AName)
{
	std::vector<AnsiString>::iterator pos = std::find(FBookNames.begin(), FBookNames.end(), AName);
	if( pos == FBookNames.end()) return -1;
	return pos - FBookNames.begin();
}
//----------------------------------------------------------------------------
void TMLExcel::NewWorkbook()
{
   if( Connect)
   {
	  var_Excel.OlePropertyGet("WorkBooks").OleFunction("Add");
	  UpdateBookList();
   }
}
//----------------------------------------------------------------------------
bool TMLExcel::NewWorkbook(const AnsiString& FileName, bool Overwrite)
{
   if (Connect && (FileExists(FileName) && Overwrite) || !FileExists(FileName))
   {
	  try
	  {
		if(IndexOfWorkbooks(FileName)<0)
		   {
			  var_Excel.OlePropertyGet("WorkBooks").OleFunction("Add");
			  UpdateBookList();
			  int count = GetWorkbookCount();
			  var_Excel.OlePropertyGet("Workbooks",count).OleFunction("SaveAs",FileName.c_str());
			  UpdateBookList();
			  return true;
		   }
		else
		   {
			  CloseWorkbook(FileName);
			  var_Excel.OlePropertyGet("WorkBooks").OleFunction("Add");
			  UpdateBookList();
			  var_Excel.OlePropertyGet("Workbooks",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;
		  var_Excel=CreateOleObject("Excel.Application");
          var_Excel.OlePropertySet("Visible", FVisible);
          UpdateBookList();
        }
		 catch (...)
         {

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

//----------------------------------------------------------------------------
std::vector<AnsiString> __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 FWorkbooks[Index];
   }
   else return NULL;
}
//----------------------------------------------------------------------------
Variant __fastcall TMLExcel::GetBooks()
{
   return var_Excel.OlePropertyGet("Workbooks");
}
//---------------------------------------------------------------------------- //---------------------------------------------------------------------------

#pragma package(smart_init)

Am Beispielcode ändert sich nur eine Zeile
in der vorletzten Zeile muss dann stehen

ShowMessage(Excel->Books[0]->Sheets[0].GetCellString(1,1));

Viel Spass bei ausprobieren und durchschauen.

[edit] 15.01.2009
Code von den bis jetzt erkannten fehlern berfreit.
[edit]

[Jansen]

Es wäre schön, wenn das mal jemand ausprobieren könnte, um zu sehen, ob noch Fragen oder Unklarheiten bestehen.
Mangels MS Office habe ich selbst leider keine Möglichkeit dazu.

[Linnea]

Hinweis: die Zeilenangaben beziehen sich auf den gepostete Quellcode

beim kompilieren bekomm ich 2 Fehler:
in Zeile 167: 'auto_ptr' ist kein Element von 'std'
in Zeile 314: 'out_of_range' ist kein Element von 'std'

welche includes fehlen da noch? eventuell "#include <memory>" und "#include <bitset>"?

wenn ich diese beiden verwende, wird alles kompiliert, allerdings kann ich keine Excel-Datei öffnen, da Zeile 476/575 immer 0 liefert. was mach ich falsch?

Testumgebung: WinXP SP3, Excel 2003, BCB6

[Braunstein]

Es fehlen die includes <memory> und <stdexcept>. Bezüglich der Fehler schau ich mal nach. Bei mir hatte es eigentlich funktioniert.

[Linnea]

ich glaube Zeile 362 sollte eher so lauten:

if(IndexOfWorkbooks(BookName) > 0) return false;

das ist - wenn ich nicht irre - der Test, ob die gewünschte Datei schon geöffnet ist

Da die Abfrage

ShowMessage(Excel->Books[0]->Sheets[0].GetCellString(0,0));

einen Ausnahmefehler verursacht, geht die Zählung der Reihen und Spalten wahrscheinlich bei 1 los. Auch entsprechende Tests mit Zeilen und Spalten ergaben das. So wird die allererste Zelle ausgelesen:

ShowMessage(Excel->Books[0]->Sheets[0].GetCellString(1,1));

Ich werd mal weiter testen, hab da so ein kleines Programm mit dem ich komplette Excel-Dateien auslesen und in eine DB speichern muß, allerdings sind neuerdings Bilder mit drin und das schafft meine verwendete Excel-Klasse nicht. Allerdings braucht man für meine Version kein Excel

[Braunstein]

Linnea schrieb:

ich glaube Zeile 362 sollte eher so lauten:

if(IndexOfWorkbooks(BookName) > 0) return false;

das ist - wenn ich nicht irre - der Test, ob die gewünschte Datei schon geöffnet ist

Fast, es sollte da nur return true kommen, da ja das Workbook korrekt geöffnet ist.
Das mit den Zellen kann schon sein ich hatte einen eigenen Test genommen wo diese zeile so nicht vorkam.

[JBOpael]

Hallo,

Kann es sein das das ganze nicht unter Office 2007 funktioniert? Mit Office 2003 bekomm ich keine Fehler.
Sobald ich die variable inizialisiere dann bekomm ich zugriffsverletzungsfehler.

TMLExcel *Test=new TMLExcel;   \\<- Acces Violation Fehler

Habt ihr ne ahnung was ich dagegen machen kann??