/*
 * ExcelWorkBook.h 
 * Copyright (c) 2012 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


//2010/04/08
//2010/05/05

#pragma once

#include <sol/office/ExcelApplet.h>

namespace SOL {


class ExcelWorkBook :public Object {

private:
    Excel::_WorkbookPtr workBook;

public:
    ExcelWorkBook(Excel::_WorkbookPtr book)
        :workBook(book)
    {

    }

public:
    ~ExcelWorkBook()
    {
        workBook = NULL;
    }
/*
public:

    HRESULT close(
        const _variant_t & saveChanges = vtMissing,
        const _variant_t & filename = vtMissing,
        const _variant_t & routeWorkbook = vtMissing,
        long lcid = 0 )
    {
        return workBook->Close (
               saveChanges,
            filename,
               routeWorkbook,
            lcid);

    }

public:
    HRESULT save(long lcid=0)
    {
        return workBook->Save(lcid);
    }

public:
*/
/*
enum XlFileFormat
{
    xlAddIn = 18,
    xlCSV = 6,
    xlCSVMac = 22,
    xlCSVMSDOS = 24,
    xlCSVWindows = 23,
    xlDBF2 = 7,
    xlDBF3 = 8,
    xlDBF4 = 11,
    xlDIF = 9,
    xlExcel2 = 16,
    xlExcel2FarEast = 27,
    xlExcel3 = 29,
    xlExcel4 = 33,
    xlExcel5 = 39,
    xlExcel7 = 39,
    xlExcel9795 = 43,
    xlExcel4Workbook = 35,
    xlIntlAddIn = 26,
    xlIntlMacro = 25,
    xlWorkbookNormal = -4143,
    xlSYLK = 2,
    xlTemplate = 17,
    xlCurrentPlatformText = -4158,
    xlTextMac = 19,
    xlTextMSDOS = 21,
    xlTextPrinter = 36,
    xlTextWindows = 20,
    xlWJ2WD1 = 14,
    xlWK1 = 5,
    xlWK1ALL = 31,
    xlWK1FMT = 30,
    xlWK3 = 15,
    xlWK4 = 38,
    xlWK3FM3 = 32,
    xlWKS = 4,
    xlWorks2FarEast = 28,
    xlWQ1 = 34,
    xlWJ3 = 40,
    xlWJ3FJ3 = 41,
    xlUnicodeText = 42,
    xlHtml = 44,
    xlWebArchive = 45,
    xlXMLSpreadsheet = 46,
    xlExcel12 = 50,
    xlOpenXMLWorkbook = 51,
    xlOpenXMLWorkbookMacroEnabled = 52,
    xlOpenXMLTemplateMacroEnabled = 53,
    xlTemplate8 = 17,
    xlOpenXMLTemplate = 54,
    xlAddIn8 = 18,
    xlOpenXMLAddIn = 55,
    xlExcel8 = 56,
    xlOpenDocumentSpreadsheet = 60,
    xlWorkbookDefault = 51
};
enum XlSaveAsAccessMode
{
    xlExclusive = 3,
    xlNoChange = 1,
    xlShared = 2
};
    
*/

    HRESULT saveAs (
        const _variant_t & filename,
        const _variant_t & fileFormat,
        const _variant_t & password=vtMissing,
        const _variant_t & writeResPassword=vtMissing,
        const _variant_t & readOnlyRecommended=vtMissing,
        const _variant_t & createBackup=vtMissing,
        enum Excel::XlSaveAsAccessMode accessMode=Excel::xlNoChange,
        const _variant_t & conflictResolution = vtMissing,
        const _variant_t & addToMru = vtMissing,
        const _variant_t & textCodepage = vtMissing,
        const _variant_t & textVisualLayout = vtMissing,
        const _variant_t & local = vtMissing,
        long lcid = 0 )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = workBook-> SaveAs (
            filename,
            fileFormat,
            password,
            writeResPassword,
            readOnlyRecommended,
            createBackup,
            accessMode,
            conflictResolution,
            addToMru,
            textCodepage,
            textVisualLayout,
            local,
            lcid)) ) {
            throw hr;
        }
        return hr;
    }

public:

    Excel::_ApplicationPtr getApplication ( )
    {
        return workBook->GetApplication ( );
    }

    
    enum Excel::XlCreator getCreator ( )
    {
        return workBook->GetCreator ( );
    }

    
    IDispatchPtr getParent ( )
    {
        return workBook->GetParent ( );
    }

    
    VARIANT_BOOL getAcceptLabelsInFormulas ( )
    {
        return workBook->GetAcceptLabelsInFormulas ( );
    }

    
    void putAcceptLabelsInFormulas (
            VARIANT_BOOL RHS )
    {
        workBook->PutAcceptLabelsInFormulas (
                RHS );
    }

    
    HRESULT activate (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Activate (
                lcid))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::_ChartPtr getActiveChart ( )
    {
        return workBook->GetActiveChart ( );
    }

    
    IDispatchPtr getActiveSheet ( )
    {
        return workBook->GetActiveSheet ( );
    }

    
    _bstr_t getAuthor (
            long lcid = 0 )
    {
        return workBook->GetAuthor (
                lcid);
    }

    
    void putAuthor (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutAuthor (
                lcid,
                rhs );
    }

    
    long getAutoUpdateFrequency ( )
    {
        return workBook->GetAutoUpdateFrequency ( );
    }

    
    void putAutoUpdateFrequency (
            long rhs )
    {
        workBook->PutAutoUpdateFrequency (
                rhs );
    }

    
    VARIANT_BOOL getAutoUpdateSaveChanges ( )
    {
        return workBook->GetAutoUpdateSaveChanges ( );
    }

    
    void putAutoUpdateSaveChanges (
            VARIANT_BOOL rhs )
    {
        workBook->PutAutoUpdateSaveChanges (
                rhs );
    }

    
    long getChangeHistoryDuration ( )
    {
        return workBook->GetChangeHistoryDuration ( );
    }

    
    void putChangeHistoryDuration (
            long rhs )
    {
        workBook->PutChangeHistoryDuration (
                rhs );
    }

    
    IDispatchPtr getBuiltinDocumentProperties ( )
    {
        return workBook->GetBuiltinDocumentProperties ( );
    }

    
    HRESULT changeFileAccess (
            enum Excel::XlFileAccess mode,
            const _variant_t & writePassword = vtMissing,
            const _variant_t & notify = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ChangeFileAccess (
                mode,
                writePassword,
                notify,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT changeLink (
            _bstr_t name,
            _bstr_t newName,
            enum Excel::XlLinkType type,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ChangeLink (
                name,
                newName,
                type,
                lcid  ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::SheetsPtr getCharts ( )
    {
        return workBook->GetCharts ( );
    }

    
    HRESULT close (
            const _variant_t & saveChanges = vtMissing,
            const _variant_t & filename = vtMissing,
            const _variant_t & routeWorkbook = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Close (
                saveChanges ,
                filename,
                routeWorkbook,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    _bstr_t getCodeName ( )
    {
        return workBook->GetCodeName ( );
    }

    
    _bstr_t get_CodeName ( )
    {
        return workBook->Get_CodeName ( );
    }

    
    void put_CodeName (
            _bstr_t rhs )
    {
        workBook->Put_CodeName (
                rhs );
    }

    
    _variant_t getColors (
            const _variant_t & index = vtMissing,
            long lcid = 0 )
    {
        return workBook->GetColors (
                index,
                lcid );
    }

    
    void putColors (
            const _variant_t & index,
            long lcid = 0,
            const _variant_t & rhs = vtMissing )
    {
        workBook->PutColors (
                index,
                lcid,
                rhs );
    }

    
    Office::_CommandBarsPtr getCommandBars ( )
    {
        return workBook->GetCommandBars ( );
    }

    
    _bstr_t getComments (
            long lcid = 0 )
    {
        return workBook->GetComments (
                lcid);
    }

    
    void putComments (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutComments (
                lcid,
                rhs );
    }

    
    enum Excel::XlSaveConflictResolution getConflictResolution ( )
    {
        return workBook->GetConflictResolution ( );
    }

    
    void putConflictResolution (
            enum Excel::XlSaveConflictResolution rhs )
    {
        workBook->PutConflictResolution (
                rhs );
    }

    
    IDispatchPtr getContainer ( )
    {
        return workBook->GetContainer ( );
    }

    
    VARIANT_BOOL getCreateBackup (
            long lcid = 0 )
    {
        return workBook->GetCreateBackup (
                lcid );
    }

    
    IDispatchPtr getCustomDocumentProperties ( )
    {
        return workBook->GetCustomDocumentProperties ( );
    }

    
    VARIANT_BOOL getDate1904 (
            long lcid = 0 )
    {
        return workBook->GetDate1904 (
                lcid );

    }

    
    void putDate1904 (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutDate1904 (
                lcid,
                rhs );
    }

    
    HRESULT deleteNumberFormat (
            _bstr_t numberFormat,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->DeleteNumberFormat (
                numberFormat,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::SheetsPtr getDialogSheets ( )
    {
        return workBook->GetDialogSheets ( );
    }

        enum Excel::XlDisplayDrawingObjects getDisplayDrawingObjects (
            long lcid = 0 )
    {
        return workBook->GetDisplayDrawingObjects (
                lcid );
    }

        void putDisplayDrawingObjects (
            long lcid,
            enum Excel::XlDisplayDrawingObjects rhs )
    {
        workBook->PutDisplayDrawingObjects (
                lcid,
                rhs );
    }

    
    VARIANT_BOOL exclusiveAccess (
            long lcid = 0 )
    {
        return workBook->ExclusiveAccess (
                lcid );
    }

        
    enum Excel::XlFileFormat getFileFormat (
            long lcid = 0 )
    {
        return workBook->GetFileFormat (
                lcid );
    }

    
    HRESULT forwardMailer (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ForwardMailer (
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    _bstr_t getFullName (
            long lcid = 0 )
    {
        return workBook->GetFullName (
                lcid );
    }

    
    VARIANT_BOOL getHasMailer (
            long lcid = 0 )
    {
        return workBook->GetHasMailer (
                lcid );
    }

    
    void putHasMailer (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutHasMailer (
                lcid,
                rhs );
    }

    
    VARIANT_BOOL getHasPassword (
            long lcid = 0 )
    {
        return workBook->GetHasPassword (
                lcid );
    }

    
    VARIANT_BOOL getHasRoutingSlip (
            long lcid = 0 )
    {
        return workBook->GetHasRoutingSlip (
                lcid );
    }

    
    void putHasRoutingSlip (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutHasRoutingSlip (
                lcid,
                rhs );
    }

    
    VARIANT_BOOL getIsAddin ( )
    {
        return workBook->GetIsAddin ( );
    }

    
    void putIsAddin (
            VARIANT_BOOL rhs )
    {
        workBook->PutIsAddin (
                rhs );
    }

    
    _bstr_t getKeywords (
            long lcid = 0 )
    {
        return workBook->GetKeywords (
                lcid );
    }

    
    void putKeywords (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutKeywords (
                lcid,
                rhs );
    }

    
    _variant_t linkInfo (
            _bstr_t name,
            enum Excel::XlLinkInfo linkInfo,
            const _variant_t & type = vtMissing,
            const _variant_t & editionRef = vtMissing,
            long lcid = 0 )
    {
        return workBook-> LinkInfo (
                name,
                linkInfo,
                type,
                editionRef,
                lcid );
    }

    
    _variant_t linkSources (
            const _variant_t & type = vtMissing,
            long lcid = 0 )
    {
        return workBook->LinkSources (
                type,
                lcid );
    }

    
    Excel::MailerPtr getMailer ( )
    {
        return workBook->GetMailer ( );
    }

    
    HRESULT mergeWorkbook (
            const _variant_t & filename )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->MergeWorkbook (
                filename ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::SheetsPtr getModules ( )
    {
        return workBook->GetModules ( );
    }

    
    VARIANT_BOOL getMultiUserEditing (
            long lcid = 0 )
    {
        return workBook->GetMultiUserEditing (
                lcid );
    }

    
    _bstr_t getName ( )
    {
        return workBook->GetName ( );
    }

    
    Excel::NamesPtr getNames ( )
    {
        return workBook->GetNames ( );
    }

    
    Excel::WindowPtr newWindow (
            long lcid = 0 )
    {
        return workBook->NewWindow (
                lcid );
    }

    
    _bstr_t getOnSave (
            long lcid = 0 )
    {
        return workBook->GetOnSave (
                lcid );
    }

    
    void putOnSave (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutOnSave (
                lcid,
                rhs );
    }

    
    _bstr_t getOnSheetActivate (
            long lcid = 0 )
    {
        return workBook-> GetOnSheetActivate (
                lcid );
    }

    
    void putOnSheetActivate (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutOnSheetActivate (
                lcid,
                rhs );
    }

        _bstr_t getOnSheetDeactivate (
            long lcid = 0 )
    {
        return workBook->GetOnSheetDeactivate (
                lcid );
    }

    
    void putOnSheetDeactivate (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutOnSheetDeactivate (
                lcid,
                rhs );
    }

    
    HRESULT openLinks (
            _bstr_t name,
            const _variant_t & readOnly = vtMissing,
            const _variant_t & type = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->OpenLinks (
                name,
                readOnly,
                type,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    _bstr_t getPath (
            long lcid = 0 )
    {
        return workBook->GetPath (
                lcid );
    }


    
    VARIANT_BOOL getPersonalViewListSettings ( )
    {
        return workBook->GetPersonalViewListSettings ( );
    }

    
    void putPersonalViewListSettings (
            VARIANT_BOOL rhs )
    {
        workBook->PutPersonalViewListSettings (
                rhs );
    }

    
    VARIANT_BOOL getPersonalViewPrintSettings ( )
    {
        return workBook->GetPersonalViewPrintSettings ( );
    }

    
    void putPersonalViewPrintSettings (
            VARIANT_BOOL rhs )
    {
        workBook->PutPersonalViewPrintSettings (
                rhs );
    }

    
    Excel::PivotCachesPtr pivotCaches ( )
    {
        return workBook->PivotCaches ( );
    }

    
    HRESULT post (
            const _variant_t & destName = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Post (
                destName,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getPrecisionAsDisplayed (
            long lcid = 0 )
    {
        return workBook->GetPrecisionAsDisplayed (
                lcid );
    }

    
    void putPrecisionAsDisplayed (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutPrecisionAsDisplayed (
                lcid,
                rhs );
    }

    
    HRESULT printOut (
            const _variant_t & from = vtMissing,
            const _variant_t & to = vtMissing,
            const _variant_t & copies = vtMissing,
            const _variant_t & preview = vtMissing,
            const _variant_t & activePrinter = vtMissing,
            const _variant_t & printToFile = vtMissing,
            const _variant_t & collate = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->_PrintOut (
                from,
                to,
                copies,
                preview,
                activePrinter,
                printToFile,
                collate,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT printPreview (
            const _variant_t & enableChanges = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->PrintPreview (
                enableChanges,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT protectSharing (
            const _variant_t & filename = vtMissing,
            const _variant_t & password = vtMissing,
            const _variant_t & writeResPassword = vtMissing,
            const _variant_t & readOnlyRecommended = vtMissing,
            const _variant_t & createBackup = vtMissing,
            const _variant_t & sharingPassword = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ProtectSharing (
                filename,
                password,
                writeResPassword,
                readOnlyRecommended,
                createBackup,
                sharingPassword ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getProtectStructure ( )
    {
        return workBook->GetProtectStructure ( );
    }

    
    VARIANT_BOOL getProtectWindows ( )
    {
        return workBook->GetProtectWindows ( );
    }

    
    VARIANT_BOOL getReadOnly (
            long lcid = 0 )
    {
        return workBook->GetReadOnly (
                lcid );
    }

    
    VARIANT_BOOL getReadOnlyRecommended (
            long lcid = 0 )
    {
        return workBook->Get_ReadOnlyRecommended (
                lcid );
    }

    ////    
    HRESULT refreshAll ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->RefreshAll ( ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT reply (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Reply (
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT replyAll (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ReplyAll (
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT removeUser (
            long Index )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->RemoveUser (
                Index ))) {
            throw hr;
        }
        return hr;
    }

    
    long getRevisionNumber (
            long lcid = 0 )
    {
        return workBook->GetRevisionNumber (
                lcid );
    }

    
    HRESULT route (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Route (
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getRouted (
            long lcid = 0 )
    {
        return workBook->GetRouted (
                lcid );
    }

    
    Excel::RoutingSlipPtr getRoutingSlip ( )
    {
        return workBook->GetRoutingSlip ( );
    }

    
    HRESULT runAutoMacros (
            enum Excel::XlRunAutoMacro which,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->RunAutoMacros (
                which,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT save (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Save (
                lcid ))) {
            throw hr;
        }
        return hr;
    }


    HRESULT _saveAs (
            const _variant_t & filename,
            const _variant_t & fileFormat,
            const _variant_t & password,
            const _variant_t & writeResPassword,
            const _variant_t & readOnlyRecommended,
            const _variant_t & createBackup,
            enum Excel::XlSaveAsAccessMode accessMode,
            const _variant_t & conflictResolution = vtMissing,
            const _variant_t & addToMru = vtMissing,
            const _variant_t & textCodepage = vtMissing,
            const _variant_t & textVisualLayout = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->_SaveAs (
                filename,
                fileFormat,
                password,
                writeResPassword,
                readOnlyRecommended,
                createBackup,
                accessMode,
                conflictResolution,
                addToMru,
                textCodepage,
                textVisualLayout,
                lcid ))) {
            throw hr;
        }
        return hr;
    }
    
    
    HRESULT saveCopyAs (
            const _variant_t & filename = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SaveCopyAs (
                filename,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getSaved (
            long lcid = 0 )
    {
        return workBook->GetSaved (
                lcid );
    }

        void putSaved (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutSaved (
                lcid,
                rhs );
    }

        VARIANT_BOOL getSaveLinkValues (
            long lcid = 0 )
    {
        return workBook->GetSaveLinkValues (
                lcid );
    }

    
    void putSaveLinkValues (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutSaveLinkValues (
                lcid,
                rhs );
    }

    
    HRESULT sendMail (
            const _variant_t & recipients,
            const _variant_t & subject = vtMissing,
            const _variant_t & returnReceipt = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SendMail (
                recipients,
                subject,
                returnReceipt,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT sendMailer (
            const _variant_t & fileFormat,
            enum Excel::XlPriority priority,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SendMailer (
                fileFormat,
                priority,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT setLinkOnData (
            _bstr_t name,
            const _variant_t & procedure = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SetLinkOnData (
                name,
                procedure,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::SheetsPtr getSheets ( )
    {
        return workBook->GetSheets ( );
    }

    
    VARIANT_BOOL getShowConflictHistory (
            long lcid = 0 )
    {
        return workBook->GetShowConflictHistory (
                lcid );
    }

    
    void putShowConflictHistory (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutShowConflictHistory (
                lcid,
                rhs );
    }

    
    Excel::StylesPtr getStyles ( )
    {
        return workBook->GetStyles ( );
    }

    
    _bstr_t getSubject (
            long lcid = 0 )
    {
        return workBook->GetSubject (
                lcid );
    }

    
    void putSubject (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutSubject (
                lcid,
                rhs );
    }

    
    _bstr_t getTitle (
            long lcid = 0 )
    {
        return workBook->GetTitle (
                lcid );
    }

    
    void putTitle (
            long lcid,
            _bstr_t rhs )
    {
        workBook->PutTitle (
                lcid,
                rhs );
    }

    
    HRESULT unprotect (
            const _variant_t & password = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Unprotect (
                password,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT unprotectSharing (
            const _variant_t & sharingPassword = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->UnprotectSharing (
                sharingPassword ))) {
            throw hr;
        }
        return hr;
    }

    HRESULT updateFromFile (
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->UpdateFromFile (
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT updateLink (
            const _variant_t & name = vtMissing,
            const _variant_t & type = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->UpdateLink (
                name,
                type,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getUpdateRemoteReferences (
            long lcid = 0 )
    {
        return workBook->GetUpdateRemoteReferences (
                lcid );
    }

    
    void putUpdateRemoteReferences (
            long lcid,
            VARIANT_BOOL rhs )
    {
        workBook->PutUpdateRemoteReferences (
                lcid,
                rhs );
    }

    
    VARIANT_BOOL getUserControl ( )
    {
        return workBook->GetUserControl ( );
    }

    void putUserControl (
            VARIANT_BOOL rhs )
    {
        workBook->PutUserControl (
                rhs );
    }

    
    _variant_t getUserStatus (
            long lcid = 0 )
    {
        return workBook->GetUserStatus (
                lcid );
    }
    
    Excel::CustomViewsPtr getCustomViews ( )
    {
        return workBook->GetCustomViews ( );
    }

    
    Excel::WindowsPtr getWindows ( )
    {
        return workBook->GetWindows ( );
    }

    
    Excel::SheetsPtr getWorksheets ( )
    {
        return workBook->GetWorksheets ( );
    }
    ////

    
    VARIANT_BOOL getWriteReserved (
            long lcid = 0 )
    {
        return workBook->GetWriteReserved (
                lcid );
    }

    
    _bstr_t getWriteReservedBy (
            long lcid = 0 )
    {
        return workBook->GetWriteReservedBy (
                lcid );
    }

    
    Excel::SheetsPtr getExcel4IntlMacroSheets ( )
    {
        return workBook->GetExcel4IntlMacroSheets ( );
    }

    
    Excel::SheetsPtr getExcel4MacroSheets ( )
    {
        return workBook->GetExcel4MacroSheets ( );
    }

    
    VARIANT_BOOL getTemplateRemoveExtData ( )
    {
        return workBook->GetTemplateRemoveExtData ( );

    }

    void putTemplateRemoveExtData (
            VARIANT_BOOL rhs )
    {
        workBook->PutTemplateRemoveExtData (
                rhs );
    }

    
    HRESULT highlightChangesOptions (
            const _variant_t & when = vtMissing,
            const _variant_t & who = vtMissing,
            const _variant_t & where = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->HighlightChangesOptions (
                when,
                who,
                where ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getHighlightChangesOnScreen ( )
    {
        return workBook->GetHighlightChangesOnScreen ( );
    }

    
    void putHighlightChangesOnScreen (
            VARIANT_BOOL rhs )
    {
        workBook->PutHighlightChangesOnScreen (
                rhs );
    }

    
    VARIANT_BOOL getKeepChangeHistory ( )
    {
        return workBook->GetKeepChangeHistory ( );
    }

    void putKeepChangeHistory (
            VARIANT_BOOL rhs )
    {
        workBook->PutKeepChangeHistory (
                rhs );
    }

    
    VARIANT_BOOL getListChangesOnNewSheet ( )
    {
        return workBook->GetListChangesOnNewSheet ( );
    }

    
    void putListChangesOnNewSheet (
            VARIANT_BOOL rhs )
    {
        workBook->PutListChangesOnNewSheet (
                rhs );
    }

    
    HRESULT purgeChangeHistoryNow (
            long days,
            const _variant_t & sharingPassword = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->PurgeChangeHistoryNow (
                days,
                sharingPassword ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT acceptAllChanges (
            const _variant_t & when = vtMissing,
            const _variant_t & who = vtMissing,
            const _variant_t & where = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->AcceptAllChanges (
                when,
                who,
                where ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT rejectAllChanges (
            const _variant_t & when = vtMissing,
            const _variant_t & who = vtMissing,
            const _variant_t & where = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->RejectAllChanges (
                when,
                who,
                where ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT pivotTableWizard (
            const _variant_t & sourceType = vtMissing,
            const _variant_t & sourceData = vtMissing,
            const _variant_t & tableDestination = vtMissing,
            const _variant_t & tableName = vtMissing,
            const _variant_t & rowGrand = vtMissing,
            const _variant_t & columnGrand = vtMissing,
            const _variant_t & saveData = vtMissing,
            const _variant_t & hasAutoFormat = vtMissing,
            const _variant_t & autoPage = vtMissing,
            const _variant_t & reserved = vtMissing,
            const _variant_t & backgroundQuery = vtMissing,
            const _variant_t & optimizeCache = vtMissing,
            const _variant_t & pageFieldOrder = vtMissing,
            const _variant_t & pageFieldWrapCount = vtMissing,
            const _variant_t & readData = vtMissing,
            const _variant_t & connection = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->PivotTableWizard (
                sourceType,
                sourceData,
                tableDestination,
                tableName,
                rowGrand,
                columnGrand,
                saveData,
                hasAutoFormat,
                autoPage,
                reserved,
                backgroundQuery,
                optimizeCache,
                pageFieldOrder,
                pageFieldWrapCount,
                readData,
                connection,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT resetColors ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ResetColors ( ))) {
            throw hr;
        }
        return hr;
    }

    
    VBIDE::_VBProjectPtr getVBProject ( )
    {
        return workBook->GetVBProject ( );
    }

    
    HRESULT followHyperlink (
            _bstr_t address,
            const _variant_t & subAddress = vtMissing,
            const _variant_t & newWindow = vtMissing,
            const _variant_t & addHistory = vtMissing,
            const _variant_t & extraInfo = vtMissing,
            const _variant_t & method = vtMissing,
            const _variant_t & headerInfo = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->FollowHyperlink (
                address,
                subAddress,
                newWindow,
                addHistory,
                extraInfo,
                method,
                headerInfo ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT addToFavorites ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->AddToFavorites ( ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getIsInplace ( )
    {
        return workBook->GetIsInplace ( );
    }

    
    HRESULT printOut (
            const _variant_t & from = vtMissing,
            const _variant_t & to = vtMissing,
            const _variant_t & copies = vtMissing,
            const _variant_t & preview = vtMissing,
            const _variant_t & activePrinter = vtMissing,
            const _variant_t & printToFile = vtMissing,
            const _variant_t & collate = vtMissing,
            const _variant_t & prToFileName = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->PrintOut (
                from,
                to,
                copies,
                preview,
                activePrinter,
                printToFile,
                collate,
                prToFileName,
                lcid ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT webPagePreview ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->WebPagePreview ( ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::PublishObjectsPtr getPublishObjects ( )
    {
        return workBook->GetPublishObjects ( );
    }

    
    Excel::WebOptionsPtr getWebOptions ( )
    {
        return workBook->GetWebOptions ( );
    }

    
    HRESULT reloadAs (
            enum Office::MsoEncoding encoding )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ReloadAs (
                encoding ))) {
            throw hr;
        }
        return hr;
    }

    
    Office::HTMLProjectPtr getHTMLProject ( )
    {
        return workBook->GetHTMLProject ( );
    }

    
    VARIANT_BOOL getEnvelopeVisible ( )
    {
        return workBook->GetEnvelopeVisible ( );
    }

    
    void putEnvelopeVisible (
            VARIANT_BOOL rhs )
    {
        workBook->PutEnvelopeVisible (
                rhs );
    }

    
    long getCalculationVersion ( )
    {
        return workBook->GetCalculationVersion ( );
    }
    
    HRESULT sblt (
            _bstr_t s )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->sblt (
                s ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getVBASigned ( )
    {
        return workBook->GetVBASigned ( );
    }

    
    VARIANT_BOOL getShowPivotTableFieldList ( )
    {
        return workBook->GetShowPivotTableFieldList ( );
    }

    
    void putShowPivotTableFieldList (
            VARIANT_BOOL rhs )
    {
        workBook->PutShowPivotTableFieldList (
                rhs );
    }

    
    enum Excel::XlUpdateLinks getUpdateLinks ( )
    {
        return workBook->GetUpdateLinks ( );
    }

    
    void putUpdateLinks (
            enum Excel::XlUpdateLinks rhs )
    {
        workBook->PutUpdateLinks (
                rhs );
    }

    
    HRESULT breakLink (
            _bstr_t name,
            enum Excel::XlLinkType type )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->BreakLink (
                name,
                type ))) {
            throw hr;
        }
        return hr;
    }

/*        
    HRESULT saveAs (
            const _variant_t & filename,
            const _variant_t & fileFormat,
            const _variant_t & password,
            const _variant_t & writeResPassword,
            const _variant_t & readOnlyRecommended,
            const _variant_t & createBackup,
            enum Excel::XlSaveAsAccessMode accessMode,
            const _variant_t & conflictResolution = vtMissing,
            const _variant_t & addToMru = vtMissing,
            const _variant_t & textCodepage = vtMissing,
            const _variant_t & textVisualLayout = vtMissing,
            const _variant_t & local = vtMissing,
            long lcid = 0 )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SaveAs (
                filename,
                fileFormat,
                password,
                writeResPassword,
                readOnlyRecommended,
                createBackup,
                accessMode,
                conflictResolution,
                addToMru,
                textCodepage,
                textVisualLayout,
                local,
                lcid ))) {
            throw hr;
        }
        return hr;
    }
*/
    
    VARIANT_BOOL getEnableAutoRecover ( )
    {
        return workBook->GetEnableAutoRecover ( );
    }

    
    void putEnableAutoRecover (
            VARIANT_BOOL rhs )
    {
        workBook->PutEnableAutoRecover (
                rhs );
    }

    
    VARIANT_BOOL getRemovePersonalInformation ( )
    {
        return workBook->GetRemovePersonalInformation ( );
    }

    
    void putRemovePersonalInformation (
            VARIANT_BOOL rhs )
    {
        workBook->PutRemovePersonalInformation (
                rhs);
    }

    
    _bstr_t getFullNameURLEncoded (
            long lcid = 0 )
    {
        return workBook->GetFullNameURLEncoded (
                lcid );
    }

        HRESULT checkIn (
            const _variant_t & saveChanges = vtMissing,
            const _variant_t & comments = vtMissing,
            const _variant_t & makePublic = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->CheckIn (
                saveChanges,
                comments,
                makePublic ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL canCheckIn ( )
    {
        return workBook->CanCheckIn ( );
    }

    
    HRESULT sendForReview (
            const _variant_t & recipients = vtMissing,
            const _variant_t & subject = vtMissing,
            const _variant_t & showMessage = vtMissing,
            const _variant_t & includeAttachment = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SendForReview (
                recipients,
                subject,
                showMessage,
                includeAttachment ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT replyWithChanges (
            const _variant_t & showMessage = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ReplyWithChanges (
                showMessage ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT endReview ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->EndReview ( ))) {
            throw hr;
        }
        return hr;
    }

    
    _bstr_t getPassword ( )
    {
        return workBook->GetPassword ( );
    }

    
    void putPassword (
            _bstr_t rhs )
    {
        workBook->PutPassword (
                rhs );
    }

    
    _bstr_t getWritePassword ( )
    {
        return workBook->GetWritePassword ( );
    }

    
    void putWritePassword (
            _bstr_t rhs )
    {
        workBook->PutWritePassword (
                rhs );
    }

    
    _bstr_t getPasswordEncryptionProvider ( )
    {
        return workBook->GetPasswordEncryptionProvider ( );
    }

    
    _bstr_t getPasswordEncryptionAlgorithm ( )
    {
        return workBook->GetPasswordEncryptionAlgorithm ( );
    }

    
    long getPasswordEncryptionKeyLength ( )
    {
        return workBook->GetPasswordEncryptionKeyLength ( );
    }

    
    HRESULT setPasswordEncryptionOptions (
            const _variant_t & passwordEncryptionProvider = vtMissing,
            const _variant_t & passwordEncryptionAlgorithm = vtMissing,
            const _variant_t & passwordEncryptionKeyLength = vtMissing,
            const _variant_t & passwordEncryptionFileProperties = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SetPasswordEncryptionOptions (
                passwordEncryptionProvider,
                passwordEncryptionAlgorithm,
                passwordEncryptionKeyLength,
                passwordEncryptionFileProperties ))) {
            throw hr;
        }
        return hr;
    }

    
    VARIANT_BOOL getPasswordEncryptionFileProperties ( )
    {
        return workBook->GetPasswordEncryptionFileProperties ( );
    }

    
    VARIANT_BOOL getReadOnlyRecommended ( )
    {
        return workBook->GetReadOnlyRecommended ( );
    }

    
    void putReadOnlyRecommended (
            VARIANT_BOOL rhs )
    {
        workBook->PutReadOnlyRecommended (
                rhs );
    }

    //
    HRESULT protect (
            const _variant_t & password = vtMissing,
            const _variant_t & structure = vtMissing,
            const _variant_t & windows = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->Protect (
                password,
                structure,
                windows ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::SmartTagOptionsPtr getSmartTagOptions ( )
    {
        return workBook->GetSmartTagOptions ( );
    }

    
    HRESULT recheckSmartTags ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->RecheckSmartTags ( ))) {
            throw hr;
        }
        return hr;
    }

    
    Office::PermissionPtr getPermission ( )
    {
        return workBook->GetPermission ( );
    }

    
    Office::SharedWorkspacePtr getSharedWorkspace ( )
    {
        return workBook->GetSharedWorkspace ( );
    }

    
    Office::SyncPtr getSync ( )
    {
        return workBook->GetSync ( );
    }

    
    HRESULT sendFaxOverInternet (
            const _variant_t & recipients = vtMissing,
            const _variant_t & subject = vtMissing,
            const _variant_t & showMessage = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->SendFaxOverInternet (
                recipients,
                subject,
                showMessage ))) {
            throw hr;
        }
        return hr;
    }

    
    Excel::XmlNamespacesPtr getXmlNamespaces ( )
    {
        return workBook->GetXmlNamespaces ( );
    }

    
    Excel::XmlMapsPtr getXmlMaps ( )
    {
        return workBook->GetXmlMaps ( );
    }

    
    enum Excel::XlXmlImportResult xmlImport (
            _bstr_t url,
            struct Excel::XmlMap * * importMap,
            const _variant_t & overwrite = vtMissing,
            const _variant_t & destination = vtMissing )
    {
        return workBook->XmlImport (
                url,
                importMap,
                overwrite,
                destination );
    }

    
    Office::SmartDocumentPtr getSmartDocument ( )
    {
        return workBook->GetSmartDocument ( );
    }

    
    Office::DocumentLibraryVersionsPtr getDocumentLibraryVersions ( )
    {
        return workBook->GetDocumentLibraryVersions ( );
    }

    
    VARIANT_BOOL getInactiveListBorderVisible ( )
    {
        return workBook->GetInactiveListBorderVisible ( );
    }

    
    void putInactiveListBorderVisible (
            VARIANT_BOOL rhs )
    {
        workBook->PutInactiveListBorderVisible (
                rhs );
    }

    
    VARIANT_BOOL getDisplayInkComments ( )
    {
        return workBook->GetDisplayInkComments ( );
    }

    
    void putDisplayInkComments (
            VARIANT_BOOL rhs )
    {
        workBook->PutDisplayInkComments (
                rhs );
    }

    
    enum Excel::XlXmlImportResult xmlImportXml (
            _bstr_t data,
            struct Excel::XmlMap * * importMap,
            const _variant_t & overwrite = vtMissing,
            const _variant_t & destination = vtMissing )
    {
        return workBook-> XmlImportXml (
                data,
                importMap,
                overwrite,
                destination );
    }

    
    HRESULT saveAsXMLData (
            _bstr_t filename,
            struct Excel::XmlMap * map )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook-> SaveAsXMLData (
                filename,
                map ))) {
            throw hr;
        }
        return hr;
    }

    
    HRESULT toggleFormsDesign ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = workBook->ToggleFormsDesign ( ))) {
            throw hr;
        }
        return hr;
    }

};

}