VC实现EXCEL转换为CSV格式

/************************************************************************
 *函数名称：ConverXLSToCSV
 *功能描述：打开EXCEL文件，并转存为CSV格式文件
 *输入参数：pSrcFileName ，源文件；pDesFileName，目标文件
 *输出参数：无
 *返回结果：S_OK，成功；S_FALSE，失败
 *特别说明：无
*************************************************************************/
HRESULT ConverXLSToCSV(const char *pSrcFileName, const char *pDesFileName)
{
 //单线程方式创建COM对象
 ::CoInitialize(0);
 if(1)
 { 
  //初始化EXCEL对象
  CComDispatchDriver execlAppDsp;
  HRESULT hr = execlAppDsp.CoCreateInstance(L"Excel.Application", 0, CLSCTX_LOCAL_SERVER|CLSCTX_INPROC_SERVER); 
  //获取工作页，打开XLS文件
  CComVariant vWorkbooks;
  hr = execlAppDsp.GetPropertyByName(L"Workbooks", &vWorkbooks);
  CComDispatchDriver booksDsp(vWorkbooks.pdispVal);
  CComVariant vSrcFileName(pSrcFileName);
  hr = booksDsp.Invoke1(L"Open", &vSrcFileName);
  //关闭警告对话框
  CComVariant vDisplay(L"FALSE");
  hr = execlAppDsp.PutPropertyByName(L"DisplayAlerts", &vDisplay);
  //打开活动页，另存为CSV文件
  CComVariant vActBook;
  hr = execlAppDsp.GetPropertyByName(L"ActiveWorkbook", &vActBook);
  CComDispatchDriver activeBookDsp(vActBook.pdispVal);
  CComVariant vDesFileName(pDesFileName);
  CComVariant vFileType("6");
  hr = activeBookDsp.Invoke2(L"SaveAs", &vDesFileName, &vFileType);
  //关闭EXCEL
  execlAppDsp.Invoke0(L"Quit");
 }
 //释放
 ::CoUninitialize();

 return S_OK;
} 

国外查找的一源文件如下:

// ExcelCom.h: interface for the ExcelCom class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_EXCELCOM_H__E1613E65_0F18_454E_B424_64476E091C7C__INCLUDED_)
#define AFX_EXCELCOM_H__E1613E65_0F18_454E_B424_64476E091C7C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <atlbase.h>
extern   CComModule _Module;
#include <atlcom.h>

#include <DBTime.h>

class ExcelCom : public CComDispatchDriver
{
    bool    m_Valid;

public:

    CString sCell(int aRow, int aCol);
    VARIANT vCell(int aRow, int aCol);
    bool PutStr(int aRow,  int aCol, const char *aStr);
    bool Close();

    enum XlWindowState
    {
        xlMaximized = -4137,
        xlMinimized = -4140,
        xlNormal    = -4143
    };

    enum XlBordersIndex
    {
        xlInsideHorizontal = 12,
        xlInsideVertical   = 11,
        xlDiagonalDown     = 5,
        xlDiagonalUp       = 6,
        xlEdgeBottom       = 9,
        xlEdgeLeft         = 7,
        xlEdgeRight        = 10,
        xlEdgeTop          = 8
    } ;

    enum  XlLineStyle
    {
        xlContinuous       = 1,
        xlDash             = -4115,
        xlDashDot          = 4,
        xlDashDotDot       = 5,
        xlDot              = -4118,
        xlDouble           = -4119,
        xlSlantDashDot     = 13,
        xlLineStyleNone    = -4142
    } ;

    enum XlBorderWeight
    {
        xlHairline  = 1,
        xlMedium    = -4138,
        xlThick     = 4,
        xlThin      = 2
    } ;

    enum Constants
    {
        xlAll                   = -4104,
        xlAutomatic             = -4105,
        xlBoth                  = 1,
        xlCenter                = -4108,
        xlChecker               = 9,
        xlCircle                = 8,
        xlCorner                = 2,
        xlCrissCross            = 16,
        xlCross                 = 4,
        xlDiamond               = 2,
        xlDistributed           = -4117,
        xlDoubleAccounting      = 5,
        xlFixedValue            = 1,
        xlFormats               = -4122,
        xlGray16                = 17,
        xlGray8                 = 18,
        xlGrid                  = 15,
        xlHigh                  = -4127,
        xlInside                = 2,
        xlJustify               = -4130,
        xlLightDown             = 13,
        xlLightHorizontal       = 11,
        xlLightUp               = 14,
        xlLightVertical         = 12,
        xlLow                   = -4134,
        xlManual                = -4135,
        xlMinusValues           = 3,
        xlModule                = -4141,
        xlNextToAxis            = 4,
        xlNone                  = -4142,
        xlNotes                 = -4144,
        xlOff                   = -4146,
        xlOn                    = 1,
        xlPercent               = 2,
        xlPlus                  = 9,
        xlPlusValues            = 2,
        xlSemiGray75            = 10,
        xlShowLabel             = 4,
        xlShowLabelAndPercent   = 5,
        xlShowPercent           = 3,
        xlShowValue             = 2,
        xlSimple                = -4154,
        xlSingle                = 2,
        xlSingleAccounting      = 4,
        xlSolid                 = 1,
        xlSquare                = 1,
        xlStar                  = 5,
        xlStError               = 4,
        xlToolbarButton         = 2,
        xlTriangle              = 3,
        xlGray25                = -4124,
        xlGray50                = -4125,
        xlGray75                = -4126,
        xlBottom                = -4107,
        xlLeft                  = -4131,
        xlRight                 = -4152,
        xlTop                   = -4160,
        xl3DBar                 = -4099,
        xl3DSurface             = -4103,
        xlBar                   = 2,
        xlColumn                = 3,
        xlCombination           = -4111,
        xlCustom                = -4114,
        xlDefaultAutoFormat     = -1,
        xlMaximum               = 2,
        xlMinimum               = 4,
        xlOpaque                = 3,
        xlTransparent           = 2,
        xlBidi                  = -5000,
        xlLatin                 = -5001,
        xlContext               = -5002,
        xlLTR                   = -5003,
        xlRTL                   = -5004,
        xlFullScript            = 1,
        xlPartialScript         = 2,
        xlMixedScript           = 3,
        xlMixedAuthorizedScript = 4,
        xlVisualCursor          = 2,
        xlLogicalCursor         = 1,
        xlSystem                = 1,
        xlPartial               = 3,
        xlHindiNumerals         = 3,
        xlBidiCalendar          = 3,
        xlGregorian             = 2,
        xlComplete              = 4,
        xlScale                 = 3,
        xlClosed                = 3,
        xlColor1                = 7,
        xlColor2                = 8,
        xlColor3                = 9,
        xlConstants             = 2,
        xlContents              = 2,
        xlBelow                 = 1,
        xlCascade               = 7,
        xlCenterAcrossSelection = 7,
        xlChart4                = 2,
        xlChartSeries           = 17,
        xlChartShort            = 6,
        xlChartTitles           = 18,
        xlClassic1              = 1,
        xlClassic2              = 2,
        xlClassic3              = 3,
        xl3DEffects1            = 13,
        xl3DEffects2            = 14,
        xlAbove                 = 0,
        xlAccounting1           = 4,
        xlAccounting2           = 5,
        xlAccounting3           = 6,
        xlAccounting4           = 17,
        xlAdd                   = 2,
        xlDebugCodePane         = 13,
        xlDesktop               = 9,
        xlDirect                = 1,
        xlDivide                = 5,
        xlDoubleClosed          = 5,
        xlDoubleOpen            = 4,
        xlDoubleQuote           = 1,
        xlEntireChart           = 20,
        xlExcelMenus            = 1,
        xlExtended              = 3,
        xlFill                  = 5,
        xlFirst                 = 0,
        xlFloating              = 5,
        xlFormula               = 5,
        xlGeneral               = 1,
        xlGridline              = 22,
        xlIcons                 = 1,
        xlImmediatePane         = 12,
        xlInteger               = 2,
        xlLast                  = 1,
        xlLastCell              = 11,
        xlList1                 = 10,
        xlList2                 = 11,
        xlList3                 = 12,
        xlLocalFormat1          = 15,
        xlLocalFormat2          = 16,
        xlLong                  = 3,
        xlLotusHelp             = 2,
        xlMacrosheetCell        = 7,
        xlMixed                 = 2,
        xlMultiply              = 4,
        xlNarrow                = 1,
        xlNoDocuments           = 3,
        xlOpen                  = 2,
        xlOutside               = 3,
        xlReference             = 4,
        xlSemiautomatic         = 2,
        xlShort                 = 1,
        xlSingleQuote           = 2,
        xlStrict                = 2,
        xlSubtract              = 3,
        xlTextBox               = 16,
        xlTiled                 = 1,
        xlTitleBar              = 8,
        xlToolbar               = 1,
        xlVisible               = 12,
        xlWatchPane             = 11,
        xlWide                  = 3,
        xlWorkbookTab           = 6,
        xlWorksheet4            = 1,
        xlWorksheetCell         = 3,
        xlWorksheetShort        = 5,
        xlAllExceptBorders      = 7,
        xlLeftToRight           = 2,
        xlTopToBottom           = 1,
        xlVeryHidden            = 2,
        xlDrawingObject         = 14
    };

    ExcelCom();
    ExcelCom* operator&() {return this; }

    bool WindowState(XlWindowState ws);
    bool OpenFile(CString FName);
    bool SaveFileAs(CString FName);
    bool CloseAllBooks();

    void SetVisible(bool bVisible = true);

    bool Init();
    bool Restore();
    bool Minimiz()  { return WindowState(xlMinimized);};
    bool Maximiz()  { return WindowState(xlMaximized);};

    bool PutRange(int aRow, int aCol, CComVariant arg1);

    bool PutDoub   (int aRow, int aCol, double  aArg, int prec=0);
    bool PutDate   (int aRow, int aCol, DBTime  aArg);
    bool PutInt    (int aRow, int aCol, long    aArg);
    bool PutFormula(int aRow, int aCol, CString aFormula);

    // несколько команд
    bool ExecVbaSrc(CString cmd, int aRow = 0);
    // выполнить команду на басике
    int  xlConst(CString xl);
    bool ExecBasLine(CString cmd);     
    bool ExecBasLine(VARIANT &value, CString cmd);
    bool RunFunc(IDispatch* p, CString Name);
    bool SetProp(IDispatch* p, CString PropName, CString Val);
    bool GetPureName(CString Name, CString &PureName, VARIANT &arg);
    CComVariant GetProp(IDispatch* p, CString PropName);
   

    // интерфейс для работы с листами Exceell
    bool AddNewList();
    bool RenameList(CString ListName);
    bool DeleteList(CString ListName);
    bool SelectList(CString ListName);
    bool DeleteList(int ListNum);
    bool SelectList(int ListNum);
    CString GetListName();
    int GetListCount();

    // дополнительные возможности
    bool SetColumeWidth( int Col , int Width);
    bool SetBold       ( int Row , int Col);
    bool SetBoldLine   ( int Row);
    bool SetBoldColum  ( int Col); 
    bool SetItalic     ( int Row , int Col);
    bool SetItalicLine ( int Row);
    bool SetItalicColum( int Col);

    bool SetLineColor  ( int Col , int Color = 36);

    // деструктор
    virtual ~ExcelCom();
};

#endif // !defined(AFX_EXCELCOM_H__E1613E65_0F18_454E_B424_64476E091C7C__INCLUDED_)

 

// ExcelCom.cpp: implementation of the ExcelCom class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ExcelCom.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#include <DBMoney.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

ExcelCom::ExcelCom() : m_Valid(false)
{
}

ExcelCom::~ExcelCom()
{
    Release();
    CoUninitialize();
}

bool ExcelCom::Init()
{
    HRESULT hr = ::CoInitialize(NULL);

    if(SUCCEEDED(hr) )
    {
        CLSID   id;
        CLSIDFromProgID(L"Excel.Application", &id); 
        IDispatch* pDisp;
        hr=::CoCreateInstance(id,NULL,CLSCTX_LOCAL_SERVER,IID_IDispatch,(void**)&pDisp);
       
        if( SUCCEEDED(hr) )
        {
            this->p = pDisp;

            CComVariant res;
            hr = GetPropertyByName(L"Workbooks",&res);
            if (res.pdispVal)
            {  
                CComDispatchDriver wbDisp(res.pdispVal);
                hr=wbDisp.Invoke0(L"Add");

                m_Valid = true;
            }
        }
    }

    if(m_Valid) Minimiz();

    return m_Valid;
}

// разделение имени на чистое_имя и параметр VARIANT
bool ExcelCom::GetPureName(CString Name, CString &PureName, VARIANT &arg)
{
        CString Val;

    if(Name.Find('(') != -1)
    {
        PureName = Name.Mid(0,Name.Find('('));
        Val      = Name.Mid(Name.Find('(')+1);
        Val      = Val.Mid(0,Val.Find(')'));

        Val.TrimRight();
        Val.TrimLeft();

        // определение типа параметра
        if(Val.Left(1) == "/"" && Val.Right(1) == "/"")
        {
            // строковый
            Val.Replace("/"","");
            arg.vt      = VT_BSTR;
            arg.bstrVal = SysAllocString(Val.AllocSysString());
        }
        else if(Val == "True" || Val == "False")
        {
            // логический
            arg.vt = VT_BOOL;
            if(Val.Find("True")  != -1)  arg.boolVal = TRUE;
            if(Val.Find("False") != -1)  arg.boolVal = FALSE;
        }
        else if(Val.Left(2) == "xl")
        {
            // константа xl
            arg.vt   = VT_I4;
            arg.lVal = xlConst(Val);           
        }
        else // целочисленный //Arg.vt = VT_I2; Arg.iVal = atoi(ArgStr);
        {          
            arg.vt   = VT_I4;
            arg.lVal = atol(Val);
        }
    }
    else
    {
        PureName = Name; PureName.TrimRight(); PureName.TrimLeft();
        return false;
    }

    PureName.TrimRight(); PureName.TrimLeft();
    return true;
}

// получить свойство [например Range("D13") или Sheets(1) ]
CComVariant ExcelCom::GetProp(IDispatch* p, CString Name)
{
    // выделяем чистое имя и параметр
    VARIANT arg;
    CString PureName;  

    bool bArg = GetPureName(Name, PureName, arg);
       
    HRESULT hr;
    CComVariant res;
    CComDispatchDriver wbDisp(p);

    if(bArg)
    {
        DISPID dwDispIDRange;
   
        hr = GetIDOfName(PureName.AllocSysString(), &dwDispIDRange);
        if (FAILED(hr)) return false;
       
        DISPPARAMS dispparms;
        VARIANT vArgs[1];

        memset(vArgs, 0, sizeof(VARIANT) * 1);
       
        vArgs[0]  = arg;       
        dispparms.cArgs = 1;
        dispparms.rgvarg = vArgs;
        dispparms.cNamedArgs = 0;

        hr = wbDisp->Invoke(dwDispIDRange, IID_NULL, LOCALE_USER_DEFAULT,
                            DISPATCH_PROPERTYGET, &dispparms, &res, NULL, NULL);

        if (FAILED(hr)) return false;
    }
    else
    {      
        hr = wbDisp.GetPropertyByName(PureName.AllocSysString(),&res);
        if (FAILED(hr)) return false;
    }
       
    return res;
}

// присвоение значения выбранному свойству
bool ExcelCom::SetProp(IDispatch* p, CString PropName, CString Val)
{  
    VARIANT arg;
    CString PureName;
   
    bool bArg = GetPureName(PropName+"("+Val+")", PureName, arg);
       
    HRESULT hr;
    CComDispatchDriver wbDisp(p);
    hr = wbDisp.PutPropertyByName(PureName.AllocSysString(),&arg);

    if (FAILED(hr)) return false;
    return true;
}

// вызов метода с параметрами
bool ExcelCom::RunFunc(IDispatch* p, CString Name)
{
    CString PureName;
    VARIANT arg, res;

    bool bArg = GetPureName(Name, PureName, arg);

    HRESULT hr;
    CComDispatchDriver wbDisp(p);

    if(bArg) { hr = wbDisp.Invoke1(PureName.AllocSysString(),&arg,&res); }
    else     { hr = wbDisp.Invoke0(PureName.AllocSysString(),&res);      } 

    if (FAILED(hr)) return false;
    return true;
}
// выполнить несколько команд
bool ExcelCom::ExecVbaSrc(CString VbSrc, int aRow)
{
    int Pos = 0;
    CString cmd = "";

    if(aRow)
    {
        // это код форматирования строки
        // проводим замену формулы вида RC[1] на ячейку
        while( (Pos = VbSrc.Find("RC[")) != -1 && VbSrc.Find(']') != -1)
        {
            cmd   = CString(cmd) + VbSrc.Mid(0,Pos);
            VbSrc = VbSrc.Mid(Pos+3);
            int aCol = atol(  VbSrc.Mid( 0 , VbSrc.Find(']') )  );
            cmd = CString(cmd) + sCell(aRow,aCol);
            VbSrc = VbSrc.Mid(VbSrc.Find(']')+1);
        }
        cmd = CString(cmd) + VbSrc;
    }
    else cmd = VbSrc;

    // команды через /n
    CString line = ""; 
    while( (Pos = cmd.Find("/r/n")) != -1 )
    {
        line = cmd.Mid(0,Pos);
        cmd  = cmd.Mid(Pos+1);

        line.TrimLeft();
        line.TrimRight();

        if(line.GetLength() && line[0]!='/'')
        {
            if(ExecBasLine(line)) continue;
            else return false;
        }
    }
    cmd.TrimLeft();
    cmd.TrimRight();

    if(cmd.GetLength() && cmd[0]!='/'')
    {
        if(ExecBasLine(cmd)) return true;
        else return false;
    }
    return true;
}

// выполнить команду на басике
bool ExcelCom::ExecBasLine(CString cmd)
{
    cmd.OemToAnsi();
    std::vector<CString> vNames;
    CString Val;

    // возможные команды 
    if(cmd.Find('=') != -1)
    {
        // команда присвоениия свойству некоторого значения
        Val = cmd.Mid(cmd.Find('=')+1);
        cmd = cmd.Mid(0,cmd.Find('='));
    }
   
    // заполняем массив vNames
    while(cmd.Find('.') != -1)
    {
        CString Name = cmd.Mid(0,cmd.Find('.'));
        cmd = cmd.Mid(cmd.Find('.')+1);
        vNames.push_back(Name);
    }
       
    // получаем нужный объект  
    CComVariant res(this->CComDispatchDriver::p);  

    for(int i=0;i<vNames.size();i++)
    {      
        if(res.pdispVal)  res = GetProp(res.pdispVal , vNames[i]);
        else return false;     
    }

    if(!res.pdispVal) return false;

    bool bResult;
    // выполняем команду или присваивание значения
    if(Val.GetLength() != 0)  bResult = SetProp( res.pdispVal, cmd , Val);
    else                      bResult = RunFunc( res.pdispVal, cmd);
   
    return bResult;
}

// выполнить команду на басике (получает значение)
bool ExcelCom::ExecBasLine(VARIANT &value, CString cmd)
{
    // просто берём указанное свойство и пишим в Value
    cmd.OemToAnsi();

    std::vector<CString> vNames;
   
    // команда получает значение выражения
    if(cmd.Find('=') != -1)     cmd = cmd.Mid(cmd.Find('=')+1);
    else return false;

    // заполняем массив vNames
    while(cmd.Find('.') != -1)
    {
        CString Name = cmd.Mid(0,cmd.Find('.'));
        cmd = cmd.Mid(cmd.Find('.')+1);
        vNames.push_back(Name);
    }
    vNames.push_back(cmd);
       
    // получаем нужный объект  
    CComVariant res(this->CComDispatchDriver::p);  

    for(int i=0;i<vNames.size();i++)
    {      
        if(res.pdispVal)  res = GetProp(res.pdispVal , vNames[i]);
        else return false;     
    }

    value = res;
    return true;
}

bool ExcelCom::Restore() 
{
    SetVisible();
    return WindowState(xlNormal);
}

void ExcelCom::SetVisible(bool bVisible)
{
    CComVariant arg1(bVisible);
    PutPropertyByName(L"Visible",&arg1);
}

bool ExcelCom::OpenFile(CString FName)
{
    CComVariant res,arg1;
    HRESULT hr = GetPropertyByName(L"Workbooks",&res);

    if (res.pdispVal)
    {  
        arg1 = FName;
        CComDispatchDriver wbDisp(res.pdispVal);
        hr = wbDisp.Invoke1(L"Open",&arg1,&res);

        return true;
    }
    return false;
}

bool ExcelCom::SaveFileAs(CString FName)
{
    // сохранение файла
    CComVariant res,arg1;
    HRESULT hr = GetPropertyByName(L"ActiveWorkbook",&res);

    if (res.pdispVal)
    {  
        arg1 = FName;
        CComDispatchDriver wbDisp(res.pdispVal);
        hr = wbDisp.Invoke1(L"SaveAs",&arg1,&res);

        return true;
    }
    return false;
}

bool ExcelCom::CloseAllBooks()
{
    // сохранение файла
    CComVariant res,arg1;
    HRESULT hr = GetPropertyByName(L"Workbooks",&res);

    if (res.pdispVal)
    {  
        CComDispatchDriver wbDisp(res.pdispVal);
        hr = wbDisp.Invoke0(L"Close",&res);

        return true;
    }
    return false;
}

bool ExcelCom::WindowState(XlWindowState ws)
{
    CComVariant arg1(ws, VT_I4);
    PutPropertyByName(L"WindowState",&arg1);
    return true;
}

bool ExcelCom::Close()
{
    Invoke0(L"Quit");
    return true;
}

bool ExcelCom::PutRange(int aRow, int aCol, CComVariant arg1)
{
    HRESULT hr;
    DISPID dwDispIDRange;
   
    hr = GetIDOfName(L"Range", &dwDispIDRange);
    if (FAILED(hr)) return false;
   
    DISPPARAMS dispparms;
    VARIANT vResult,vArgs[1];

    memset(vArgs, 0, sizeof(VARIANT) * 1);
   
    vArgs[0] = vCell(aRow,aCol);

    dispparms.cArgs = 1;
    dispparms.rgvarg = vArgs;
    dispparms.cNamedArgs = 0;

    hr = (*this)->Invoke(dwDispIDRange, IID_NULL, LOCALE_USER_DEFAULT,
                DISPATCH_PROPERTYGET, &dispparms, &vResult, NULL, NULL);
    if (FAILED(hr)) return false;
   
    CComDispatchDriver spRange(vResult.pdispVal);

    hr = spRange.PutPropertyByName(L"FormulaR1C1",&arg1);
    if (FAILED(hr)) return false;

    return true;
}

bool ExcelCom::PutStr(int aRow, int aCol, const char *aStr)
{
    CString     buf(aStr);

    buf.OemToAnsi();

//  CComVariant arg1(aStr);
    CComVariant arg1(static_cast<const char*>("/'"+buf));
    return(PutRange(aRow, aCol, arg1));

}

CString ExcelCom::sCell(int aRow, int aCol)
{
    CString cell;
    const char abc[28] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // 26
   
    int n1 = (aCol-1)/26;
    int n2 = aCol%26 ? aCol%26 : 26;

    cell.Format("%c%c%d",abc[n1],abc[n2],aRow);
    cell.TrimLeft();
    return cell;
}

VARIANT ExcelCom::vCell(int aRow, int aCol)
{  
    CString cell = sCell(aRow,aCol);   
    VARIANT res;
    res.vt = VT_BSTR;
    res.bstrVal = SysAllocString(cell.AllocSysString());
    return res;
}

bool ExcelCom::PutDoub(int aRow, int aCol, double aArg, int prec)
{
    CComVariant arg1((double)DBMoney(aArg).Round(-prec));
    return(PutRange(aRow, aCol, arg1));
}

bool ExcelCom::PutDate(int aRow, int aCol, DBTime aArg)
{
    CComVariant arg1;
    arg1.vt = VT_DATE;
    arg1.date = aArg;
    return(PutRange(aRow, aCol, arg1));
}

bool ExcelCom::PutInt(int aRow,  int aCol, long aArg)
{
    CComVariant arg1(aArg);
    return(PutRange(aRow, aCol, arg1));
   
}

// интерфейс для работы с листами Exceell
bool ExcelCom::AddNewList()
{
    return ExecBasLine("ActiveWorkbook.Sheets.Add");
}

CString ExcelCom::GetListName()
{
    CComVariant val;
    ExecBasLine(val," = ActiveWindow.ActiveSheet.Name");

    if(val.vt == VT_BSTR)
    {
        CString res(val.bstrVal);
        res.AnsiToOem();
        return res;
    }
    return "";
}

int ExcelCom::GetListCount()
{
    CComVariant val;
    ExecBasLine(val," = ActiveWorkbook.Sheets.Count");

    if(val.vt == VT_I4)  return val.lVal;
    if(val.vt == VT_I2)  return val.iVal;
   
    return -1; 
}

bool ExcelCom::DeleteList(CString ListName)
{
    return ExecBasLine("ActiveWorkbook.Sheets(/""+ ListName + "/").Delete");
}

bool ExcelCom::RenameList(CString ListName)
{
    return ExecBasLine("ActiveWindow.ActiveSheet.Name = /"" + ListName + "/"");    
}

bool ExcelCom::DeleteList(int ListNum)
{
    CString cmd;   
    cmd.Format("ActiveWorkbook.Sheets(%i).Delete",ListNum);
    return ExecBasLine(cmd);
}

bool ExcelCom::SelectList(int ListNum)
{
    CString cmd;   
    cmd.Format("ActiveWorkbook.Sheets(%i).Select",ListNum);
    return ExecBasLine(cmd);
}

bool ExcelCom::SelectList(CString ListName)
{
    return ExecBasLine("ActiveWorkbook.Sheets(/"" + ListName + "/").Select");
}

bool ExcelCom::SetColumeWidth( int Col , int Width)
{
    CString cmd;   
    cmd.Format("Columns(%i).ColumnWidth = %i", Col , Width);
    return ExecBasLine(cmd);
}

bool ExcelCom::SetBold(int Row, int Col)
{
    CString cmd;
    cmd.Format("Range(/"%s/").Select",sCell(Row,Col));
    if(ExecBasLine(cmd)) return ExecBasLine("Selection.Font.Bold = True");     
    return false;
}

bool ExcelCom::SetBoldLine( int Row)
{
    CString cmd;   
    cmd.Format("Rows(%i).Select", Row);
    if(ExecBasLine(cmd)) return ExecBasLine("Selection.Font.Bold = True");     
    return false;
}

bool ExcelCom::SetBoldColum( int Col)
{
    CString cmd;   
    cmd.Format("Columns(%i).Select", Col);
    if(ExecBasLine(cmd)) return ExecBasLine("Selection.Font.Bold = True");     
    return false;
}

bool ExcelCom::SetItalic(int Row, int Col)
{
    CString cmd;
    cmd.Format("Range(/"%s/").Select",sCell(Row,Col));
    if(ExecBasLine(cmd)) return ExecBasLine("Selection.Font.Italic = True");       
    return false;
}

bool ExcelCom::SetItalicLine( int Row)
{
    CString cmd;   
    cmd.Format("Rows(%i).Select", Row);
    if(ExecBasLine(cmd)) return ExecBasLine("Selection.Font.Italic = True");       
    return false;
}

bool ExcelCom::SetItalicColum( int Col)
{
    CString cmd;   
    cmd.Format("Columns(%i).Select", Col);
    if(ExecBasLine(cmd)) return ExecBasLine("Selection.Font.Italic = True");       
    return false;
}

bool ExcelCom::SetLineColor( int Col, int Color)
{
    CString cmd1, cmd2;
    cmd1.Format("Rows(%i).Select", Col);
    cmd2.Format("Selection.Interior.ColorIndex = %i", Color);

    if(ExecBasLine(cmd1)) return ExecBasLine(cmd2);    
    return false;
}

bool ExcelCom::PutFormula(int aRow, int aCol, CString aFml)
{  
    // закидываем в Excell формулу вида
    // =SUM([#+2,_-5]:[#-1,_+2]) # - столбец _ - строка
    /*
    CString res = "", val = "";
    while(aFml.Find('[') != -1 && aFml.Find(']') != -1)
    {
        res  = CString(res) + aFml.Mid(0,aFml.Find('['));
        aFml = aFml.Mid(aFml.Find('[')+1);
        val  = aFml.Mid(0,aFml.Find(']'));
        aFml = aFml.Mid(aFml.Find(']')+1);

        // преобразование val в значение ячейки и добавление к res     
        val.Replace("#",""); val.Replace("_","");

        CString sCol = val.Mid(0,val.Find(','));
        CString sRow = val.Mid(val.Find(',')+1);       
        res = CString(res) + sCell( aRow + atol(sRow), aCol + atol(sCol));
    }

    res = CString(res) + aFml;

    CString cmd1,cmd2;
    cmd1.Format("Range(/"%s/").Select",sCell(aRow,aCol));
    cmd2.Format("ActiveCell.Formula = /"%s/"",res);

    if(ExecBasLine(cmd1)) return ExecBasLine(cmd2);    
    return false;
    */

    aFml.OemToAnsi();
    CComVariant arg1(aFml);
    return(PutRange(aRow, aCol, arg1));
}

int ExcelCom::xlConst(CString xl)
{
    if( xl == "xlMaximized")            return  xlMaximized             ;
    if( xl == "xlMinimized")            return  xlMinimized             ;
    if( xl == "xlNormal")               return  xlNormal                ;
    if( xl == "xlInsideHorizontal")     return  xlInsideHorizontal      ;
    if( xl == "xlInsideVertical")       return  xlInsideVertical        ;
    if( xl == "xlDiagonalDown")         return  xlDiagonalDown          ;
    if( xl == "xlDiagonalUp")           return  xlDiagonalUp            ;
    if( xl == "xlEdgeBottom")           return  xlEdgeBottom            ;
    if( xl == "xlEdgeLeft")             return  xlEdgeLeft              ;
    if( xl == "xlEdgeRight")            return  xlEdgeRight             ;
    if( xl == "xlEdgeTop")              return  xlEdgeTop               ;
    if( xl == "xlContinuous")           return  xlContinuous            ;
    if( xl == "xlDash")                 return  xlDash                  ;
    if( xl == "xlDashDot")              return  xlDashDot               ;
    if( xl == "xlDashDotDot")           return  xlDashDotDot            ;
    if( xl == "xlDot")                  return  xlDot                   ;
    if( xl == "xlDouble")               return  xlDouble                ;
    if( xl == "xlSlantDashDot")         return  xlSlantDashDot          ;
    if( xl == "xlLineStyleNone")        return  xlLineStyleNone         ;
    if( xl == "xlHairline")             return  xlHairline              ;
    if( xl == "xlMedium")               return  xlMedium                ;
    if( xl == "xlThick")                return  xlThick                 ;
    if( xl == "xlThin")                 return  xlThin                  ;
    if( xl == "xlAll")                  return  xlAll                   ;
    if( xl == "xlAutomatic")            return  xlAutomatic             ;
    if( xl == "xlBoth")                 return  xlBoth                  ;
    if( xl == "xlCenter")               return  xlCenter                ;
    if( xl == "xlChecker")              return  xlChecker               ;
    if( xl == "xlCircle")               return  xlCircle                ;
    if( xl == "xlCorner")               return  xlCorner                ;
    if( xl == "xlCrissCross")           return  xlCrissCross            ;
    if( xl == "xlCross")                return  xlCross                 ;
    if( xl == "xlDiamond")              return  xlDiamond               ;
    if( xl == "xlDistributed")          return  xlDistributed           ;
    if( xl == "xlDoubleAccounting")     return  xlDoubleAccounting      ;
    if( xl == "xlFixedValue")           return  xlFixedValue            ;
    if( xl == "xlFormats")              return  xlFormats               ;
    if( xl == "xlGray16 ")              return  xlGray16                ;
    if( xl == "xlGray8 ")               return  xlGray8                 ;
    if( xl == "xlGrid ")                return  xlGrid                  ;
    if( xl == "xlHigh ")                return  xlHigh                  ;
    if( xl == "xlInside ")              return  xlInside                ;
    if( xl == "xlJustify ")             return  xlJustify               ;
    if( xl == "xlLightDown ")           return  xlLightDown             ;
    if( xl == "xlLightHorizontal ")     return  xlLightHorizontal       ;
    if( xl == "xlLightUp ")             return  xlLightUp               ;
    if( xl == "xlLightVertical")        return  xlLightVertical         ;
    if( xl == "xlLow ")                 return  xlLow                   ;
    if( xl == "xlManual ")              return  xlManual                ;
    if( xl == "xlMinusValues")          return  xlMinusValues           ;
    if( xl == "xlModule")               return  xlModule                ;
    if( xl == "xlNextToAxis")           return  xlNextToAxis            ;
    if( xl == "xlNone")                 return  xlNone                  ;
    if( xl == "xlNotes")                return  xlNotes                 ;
    if( xl == "xlOff")                  return  xlOff                   ;
    if( xl == "xlOn")                   return  xlOn                    ;
    if( xl == "xlPercent")              return  xlPercent               ;
    if( xl == "xlPlus")                 return  xlPlus                  ;
    if( xl == "xlPlusValues")           return  xlPlusValues            ;
    if( xl == "xlSemiGray75")           return  xlSemiGray75            ;
    if( xl == "xlShowLabel")            return  xlShowLabel             ;
    if( xl == "xlShowLabelAndPercent")  return  xlShowLabelAndPercent   ;
    if( xl == "xlShowPercent")          return  xlShowPercent           ;
    if( xl == "xlShowValue")            return  xlShowValue             ;
    if( xl == "xlSimple")               return  xlSimple                ;
    if( xl == "xlSingle")               return  xlSingle                ;
    if( xl == "xlSingleAccounting")     return  xlSingleAccounting      ;
    if( xl == "xlSolid")                return  xlSolid                 ;
    if( xl == "xlSquare")               return  xlSquare                ;
    if( xl == "xlStar")                 return  xlStar                  ;
    if( xl == "xlStError")              return  xlStError               ;
    if( xl == "xlToolbarButton")        return  xlToolbarButton         ;
    if( xl == "xlTriangle")             return  xlTriangle              ;
    if( xl == "xlGray25")               return  xlGray25                ;
    if( xl == "xlGray50")               return  xlGray50                ;
    if( xl == "xlGray75")               return  xlGray75                ;
    if( xl == "xlBottom")               return  xlBottom                ;
    if( xl == "xlLeft")                 return  xlLeft                  ;
    if( xl == "xlRight")                return  xlRight                 ;
    if( xl == "xlTop")                  return  xlTop                   ;
    if( xl == "xl3DBar")                return  xl3DBar                 ;
    if( xl == "xl3DSurface")            return  xl3DSurface             ;
    if( xl == "xlBar")                  return  xlBar                   ;
    if( xl == "xlColumn")               return  xlColumn                ;
    if( xl == "xlCombination")          return  xlCombination           ;
    if( xl == "xlCustom")               return  xlCustom                ;
    if( xl == "xlDefaultAutoFormat")    return  xlDefaultAutoFormat     ;
    if( xl == "xlMaximum")              return  xlMaximum               ;
    if( xl == "xlMinimum")              return  xlMinimum               ;
    if( xl == "xlOpaque")               return  xlOpaque                ;
    if( xl == "xlTransparent")          return  xlTransparent           ;
    if( xl == "xlBidi")                 return  xlBidi                  ;
    if( xl == "xlLatin")                return  xlLatin                 ;
    if( xl == "xlContext")              return  xlContext               ;
    if( xl == "xlLTR")                  return  xlLTR                   ;
    if( xl == "xlRTL")                  return  xlRTL                   ;
    if( xl == "xlFullScript")           return  xlFullScript            ;
    if( xl == "xlPartialScript")        return  xlPartialScript         ;
    if( xl == "xlMixedScript")          return  xlMixedScript           ;
    if( xl == "xlMixedAuthorizedScript")return  xlMixedAuthorizedScript ;
    if( xl == "xlVisualCursor")         return  xlVisualCursor          ;
    if( xl == "xlLogicalCursor")        return  xlLogicalCursor         ;
    if( xl == "xlSystem")               return  xlSystem                ;
    if( xl == "xlPartial")              return  xlPartial               ;
    if( xl == "xlHindiNumerals")        return  xlHindiNumerals         ;
    if( xl == "xlBidiCalendar")         return  xlBidiCalendar          ;
    if( xl == "xlGregorian")            return  xlGregorian             ;
    if( xl == "xlComplete")             return  xlComplete              ;
    if( xl == "xlScale")                return  xlScale                 ;
    if( xl == "xlClosed")               return  xlClosed                ;
    if( xl == "xlColor1")               return  xlColor1                ;
    if( xl == "xlColor2")               return  xlColor2                ;
    if( xl == "xlColor3")               return  xlColor3                ;
    if( xl == "xlConstants")            return  xlConstants             ;
    if( xl == "xlContents")             return  xlContents              ;
    if( xl == "xlBelow")                return  xlBelow                 ;
    if( xl == "xlCascade")              return  xlCascade               ;
    if( xl == "xlCenterAcrossSelection")return  xlCenterAcrossSelection ;
    if( xl == "xlChart4")               return  xlChart4                ;
    if( xl == "xlChartSeries")          return  xlChartSeries           ;
    if( xl == "xlChartShort")           return  xlChartShort            ;
    if( xl == "xlChartTitles")          return  xlChartTitles           ;
    if( xl == "xlClassic1")             return  xlClassic1              ;
    if( xl == "xlClassic2")             return  xlClassic2              ;
    if( xl == "xlClassic3")             return  xlClassic3              ;
    if( xl == "xl3DEffects1")           return  xl3DEffects1            ;
    if( xl == "xl3DEffects2")           return  xl3DEffects2            ;
    if( xl == "xlAbove")                return  xlAbove                 ;
    if( xl == "xlAccounting1")          return  xlAccounting1           ;
    if( xl == "xlAccounting2")          return  xlAccounting2           ;
    if( xl == "xlAccounting3")          return  xlAccounting3           ;
    if( xl == "xlAccounting4")          return  xlAccounting4           ;
    if( xl == "xlAdd")                  return  xlAdd                   ;
    if( xl == "xlDebugCodePane")        return  xlDebugCodePane         ;
    if( xl == "xlDesktop")              return  xlDesktop               ;
    if( xl == "xlDirect")               return  xlDirect                ;
    if( xl == "xlDivide")               return  xlDivide                ;
    if( xl == "xlDoubleClosed")         return  xlDoubleClosed          ;
    if( xl == "xlDoubleOpen")           return  xlDoubleOpen            ;
    if( xl == "xlDoubleQuote")          return  xlDoubleQuote           ;
    if( xl == "xlEntireChart")          return  xlEntireChart           ;
    if( xl == "xlExcelMenus")           return  xlExcelMenus            ;
    if( xl == "xlExtended")             return  xlExtended              ;
    if( xl == "xlFill")                 return  xlFill                  ;
    if( xl == "xlFirst")                return  xlFirst                 ;
    if( xl == "xlFloating")             return  xlFloating              ;
    if( xl == "xlFormula")              return  xlFormula               ;
    if( xl == "xlGeneral")              return  xlGeneral               ;
    if( xl == "xlGridline")             return  xlGridline              ;
    if( xl == "xlIcons")                return  xlIcons                 ;
    if( xl == "xlImmediatePane")        return  xlImmediatePane         ;
    if( xl == "xlInteger")              return  xlInteger               ;
    if( xl == "xlLast")                 return  xlLast                  ;
    if( xl == "xlLastCell")             return  xlLastCell              ;
    if( xl == "xlList1")                return  xlList1                 ;
    if( xl == "xlList2")                return  xlList2                 ;
    if( xl == "xlList3")                return  xlList3                 ;
    if( xl == "xlLocalFormat1")         return  xlLocalFormat1          ;
    if( xl == "xlLocalFormat2")         return  xlLocalFormat2          ;
    if( xl == "xlLong")                 return  xlLong                  ;
    if( xl == "xlLotusHelp")            return  xlLotusHelp             ;
    if( xl == "xlMacrosheetCell")       return  xlMacrosheetCell        ;
    if( xl == "xlMixed")                return  xlMixed                 ;
    if( xl == "xlMultiply")             return  xlMultiply              ;
    if( xl == "xlNarrow")               return  xlNarrow                ;
    if( xl == "xlNoDocuments")          return  xlNoDocuments           ;
    if( xl == "xlOpen")                 return  xlOpen                  ;
    if( xl == "xlOutside")              return  xlOutside               ;
    if( xl == "xlReference")            return  xlReference             ;
    if( xl == "xlSemiautomatic")        return  xlSemiautomatic         ;
    if( xl == "xlShort")                return  xlShort                 ;
    if( xl == "xlSingleQuote")          return  xlSingleQuote           ;
    if( xl == "xlStrict")               return  xlStrict                ;
    if( xl == "xlSubtract")             return  xlSubtract              ;
    if( xl == "xlTextBox")              return  xlTextBox               ;
    if( xl == "xlTiled")                return  xlTiled                 ;
    if( xl == "xlTitleBar")             return  xlTitleBar              ;
    if( xl == "xlToolbar")              return  xlToolbar               ;
    if( xl == "xlVisible")              return  xlVisible               ;
    if( xl == "xlWatchPane")            return  xlWatchPane             ;
    if( xl == "xlWide")                 return  xlWide                  ;
    if( xl == "xlWorkbookTab")          return  xlWorkbookTab           ;
    if( xl == "xlWorksheet4")           return  xlWorksheet4            ;
    if( xl == "xlWorksheetCell")        return  xlWorksheetCell         ;
    if( xl == "xlWorksheetShort")       return  xlWorksheetShort        ;
    if( xl == "xlAllExceptBorders")     return  xlAllExceptBorders      ;
    if( xl == "xlLeftToRight")          return  xlLeftToRight           ;
    if( xl == "xlTopToBottom")          return  xlTopToBottom           ;
    if( xl == "xlVeryHidden")           return  xlVeryHidden            ;
    if( xl == "xlDrawingObject")        return  xlDrawingObject         ;

    return 0;
}