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


//2010/04/08
//2010/05/05 Added a lot of public methods.

#pragma once

#include <sol/office/OfficeApplet.h>

//MSWORD
#ifdef WIN64

#ifdef OFFICE2010
#import "C:\Program Files (x86)\Microsoft Office\OFFICE14\MSWORD.OLB" \
    rename("DocumentProperties","DocumentPropertiesXL") \
    rename("RGB","RBGXL") \
    rename("DialogBox","DialogBoxXL") \
    rename("CopyFile","CopyFileXL") \
    rename("ReplaceText","ReplaceTextXL") \
    rename("FindText","FindTextXL") \
    rename("ExitWindows","_ExitWindowsW")

#else
#import "C:\Program Files (x86)\Microsoft Office\OFFICE12\MSWORD.OLB" \
    rename("DocumentProperties","DocumentPropertiesXL") \
    rename("RGB","RBGXL") \
    rename("DialogBox","DialogBoxXL") \
    rename("CopyFile","CopyFileXL") \
    rename("ReplaceText","ReplaceTextXL") \
    rename("FindText","FindTextXL") \
    rename("ExitWindows","_ExitWindowsW")
#endif

#else

#ifdef OFFICE2010
#import "C:\Program Files\Microsoft Office\OFFICE14\MSWORD.OLB" \
    rename("DocumentProperties","DocumentPropertiesXL") \
    rename("RGB","RBGXL") \
    rename("DialogBox","DialogBoxXL") \
    rename("CopyFile","CopyFileXL") \
    rename("ReplaceText","ReplaceTextXL") \
    rename("FindText","FindTextXL") \
    rename("ExitWindows","_ExitWindowsW")

#else
#import "C:\Program Files\Microsoft Office\OFFICE12\MSWORD.OLB" \
    rename("DocumentProperties","DocumentPropertiesXL") \
    rename("RGB","RBGXL") \
    rename("DialogBox","DialogBoxXL") \
    rename("CopyFile","CopyFileXL") \
    rename("ReplaceText","ReplaceTextXL") \
    rename("FindText","FindTextXL") \
    rename("ExitWindows","_ExitWindowsW")
#endif

#endif

namespace SOL {


class WordApplet :public OfficeApplet {
private:
    Word::_ApplicationPtr word;

private:
    Word::DocumentsPtr documents;

private:
    bool isCreated;

public:
    WordApplet()
        :word(NULL),
        documents(NULL),
        isCreated(false)
    {
        IDispatch* pDisp = NULL;
        const wchar_t* application = L"Word.Application";
        if (getActiveObject(application, &pDisp)) {
            this->word = pDisp;        
            printf( "WordApplet#WordApplet,1,Found an active word object\n");
        } else {

            HRESULT hr= this->word.CreateInstance(application);
            if (FAILED(hr)) {
                throw hr;
            } else {
                printf( "WordApplet#WordApplet,2,Created a word object\n");
                isCreated = true;
            }
        }

        if (this->word) {
            this->documents = word->Documents;
        }
    }

public:
    ~WordApplet()
    {
        if (this->word) {
            if (isCreated) {
                this->documents = NULL;
                this->word->Quit();
            }
            this->documents = NULL;
            this->word = NULL;
        }    
    }


public:
    Word::_DocumentPtr open(const BSTR docName, bool visible=false)
    {
        VARIANT name;
        VariantClear(&name);
        name.vt = VT_BSTR;
        name.bstrVal = docName;

        if (isCreated) {
            if (visible==false) {
                this->word->PutVisible(FALSE);
            } else {
                this->word->PutVisible(TRUE);
            }
        }

        Word::_DocumentPtr document = NULL;

        try {
            document = this->documents->
                Open(&name, &vtMissing, &vtMissing, &vtMissing, &vtMissing, &vtMissing, 
                    &vtMissing, &vtMissing, &vtMissing, &vtMissing,
                    &vtMissing, &vtMissing, &vtMissing, &vtMissing, &vtMissing, &vtMissing);
        } catch (...) {

        }

        return document;
    }

    //2010/05/01 Added the following
public:
    Word::_ApplicationPtr getApplication ( )
    {
        return word->GetApplication ( );
       }

    long getCreator ( )
    {
        return word->GetCreator ( );
    }
    
    IDispatchPtr getParent ( )
    {
        return word->GetParent ( );
    }
    
    _bstr_t getName ( )
    {
        return word->GetName ( );
    }
    
    Word::DocumentsPtr getDocuments ( )
    {
        return word->GetDocuments ( );
    }
    
    Word::WindowsPtr getWindows ( )
    {
        return word->GetWindows ( );
    }
    
    Word::_DocumentPtr getActiveDocument ( )
    {
        return word->GetActiveDocument ( );
    }
    
    Word::WindowPtr getActiveWindow ( )
    {
        return word->GetActiveWindow ( );
    }
    
    Word::SelectionPtr getSelection ( )
    {
        return word->GetSelection ( );
    }
    
    IDispatchPtr getWordBasic ( )
    {
        return word->GetWordBasic ( );
    }
    
    Word::RecentFilesPtr getRecentFiles ( )
    {
        return word->GetRecentFiles ( );
    }
    
    Word::TemplatePtr getNormalTemplate ( )
    {
        return word->GetNormalTemplate ( );
    }
    
    Word::SystemPtr getSystem ( )
    {
        return word->GetSystem ( );
    }
    
    Word::AutoCorrectPtr getAutoCorrect ( )
    {
        return word->GetAutoCorrect ( );
    }
    
    Word::FontNamesPtr getFontNames ( )
    {
        return word->GetFontNames ( );
    }
    
    Word::FontNamesPtr getLandscapeFontNames ( )
    {
        return word->GetLandscapeFontNames ( );
    }
    
    Word::FontNamesPtr getPortraitFontNames ( )
    {
        return word->GetPortraitFontNames ( );
    }
    
    Word::LanguagesPtr getLanguages ( )
    {
        return word->GetLanguages ( );
    }
    
    Office::AssistantPtr getAssistant ( )
    {
        return word->GetAssistant ( );
    }
    
    Word::BrowserPtr getBrowser ( )
    {
        return word->GetBrowser ( );
    }
    
    Word::FileConvertersPtr getFileConverters ( )
    {
        return word->GetFileConverters ( );
    }
    
    Word::MailingLabelPtr getMailingLabel ( )
    {
        return word->GetMailingLabel ( );
    }
    
    Word::DialogsPtr getDialogs ( )
    {
        return word->GetDialogs ( );
    }
    
    Word::CaptionLabelsPtr getCaptionLabels ( )
    {
        return word->GetCaptionLabels ( );
    }
    
    Word::AutoCaptionsPtr getAutoCaptions ( )
    {
        return word->GetAutoCaptions ( );
    }
    
    Word::AddInsPtr getAddIns ( )
    {
        return word->GetAddIns ( );
    }
    
    VARIANT_BOOL getVisible ( )
    {
        return word->GetVisible ( );
    }
    
    void putVisible (
            VARIANT_BOOL prop )
    {
        word->PutVisible (
                prop );
    }
    
    _bstr_t getVersion ( )
    {
        return word->GetVersion ( );
    }
    
    VARIANT_BOOL getScreenUpdating ( )
    {
        return word->GetScreenUpdating ( );
    }
    
    void putScreenUpdating (
            VARIANT_BOOL prop )
    {
        word->PutScreenUpdating (
                prop );
    }
    
    VARIANT_BOOL getPrintPreview ( )
    {
        return word->GetPrintPreview ( );
    }
    
    void putPrintPreview (
            VARIANT_BOOL prop )
    {
        word->PutPrintPreview (
                prop );
    }
    
    Word::TasksPtr getTasks ( )
    {
        return word->GetTasks ( );
    }
    
    VARIANT_BOOL getDisplayStatusBar ( )
    {
        return word->GetDisplayStatusBar ( );
    }
    
    void putDisplayStatusBar (
            VARIANT_BOOL prop )
    {
        word->PutDisplayStatusBar (
                prop );
    }
    
    VARIANT_BOOL getSpecialMode ( )
    {
        return word->GetSpecialMode ( );
    }
    
    long getUsableWidth ( )
    {
        return word->GetUsableWidth ( );
    }
    
    long getUsableHeight ( )
    {
        return word->GetUsableHeight ( );
    }
    
    VARIANT_BOOL getMathCoprocessorAvailable ( )
    {
        return word->GetMathCoprocessorAvailable ( );
    }
    
    VARIANT_BOOL getMouseAvailable ( )
    {
        return word->GetMouseAvailable ( );
    }
    
    _variant_t getInternational (
            enum Word::WdInternationalIndex index )
    {
        return word->GetInternational (
                index );
    }
    
    _bstr_t getBuild ( )
    {
        return word->GetBuild ( );
    }
    
    VARIANT_BOOL getCapsLock ( )
    {
        return word->GetCapsLock ( );
    }
    
    VARIANT_BOOL getNumLock ( )
    {
        return word->GetNumLock ( );
    }
    
    _bstr_t getUserName ( )
    {
        return word->GetUserName ( );
    }
    
    void putUserName (
            _bstr_t prop )
    {
        word->PutUserName (
                prop );
    }
    
    _bstr_t getUserInitials ( )
    {
        return word->GetUserInitials ( );
    }
    
    void putUserInitials (
            _bstr_t prop )
    {
        word->PutUserInitials (
                prop );
    }
    
    _bstr_t getUserAddress ( )
    {
        return word->GetUserAddress ( );
    }
    
    void putUserAddress (
            _bstr_t prop )
    {
        word->PutUserAddress (
                prop );
    }
    
    IDispatchPtr getMacroContainer ( )
    {
        return word->GetMacroContainer ( );
    }
    
    VARIANT_BOOL getDisplayRecentFiles ( )
    {
        return word->GetDisplayRecentFiles ( );
    }
    
    void putDisplayRecentFiles (
            VARIANT_BOOL prop )
    {
        word->PutDisplayRecentFiles (
                prop );
    }
    
    Office::_CommandBarsPtr getCommandBars ( )
    {
        return word->GetCommandBars ( );
    }
    
    Word::SynonymInfoPtr getSynonymInfo (
            _bstr_t sword,
            VARIANT * languageID = &vtMissing )
    {
        return word->GetSynonymInfo (
                sword,
                languageID );
    }
    
    VBIDE::VBEPtr getVBE ( )
    {
        return word->GetVBE ( );
    }
    
    _bstr_t getDefaultSaveFormat ( )
    {
        return word->GetDefaultSaveFormat ( );
    }
    
    void putDefaultSaveFormat (
            _bstr_t prop )
    {
        word->PutDefaultSaveFormat (
                prop );
    }
    
    Word::ListGalleriesPtr getListGalleries ( )
    {
        return word->GetListGalleries ( );
    }
    
    _bstr_t getActivePrinter ( )
    {
        return word->GetActivePrinter ( );
    }
    
    void putActivePrinter (
            _bstr_t prop )
    {
        word->PutActivePrinter (
                prop );
    }
    
    Word::TemplatesPtr getTemplates ( )
    {
        return word->GetTemplates ( );
    }
    
    IDispatchPtr getCustomizationContext ( )
    {
        return word->GetCustomizationContext ( );
    }
    
    void putCustomizationContext (
            IDispatch * prop )
    {
        word->PutCustomizationContext (
                prop );
    }
    
    Word::KeyBindingsPtr getKeyBindings ( )
    {
        return word->GetKeyBindings ( );
    }
    
    Word::KeysBoundToPtr getKeysBoundTo (
            enum Word::WdKeyCategory keyCategory,
            _bstr_t command,
            VARIANT * commandParameter = &vtMissing )
    {
        return word->GetKeysBoundTo (
                keyCategory,
                command,
                commandParameter);
    }
    

    Word::KeyBindingPtr getFindKey (
            long keyCode,
            VARIANT * keyCode2 = &vtMissing )
    {
        return word->GetFindKey (
                keyCode,
                keyCode2 );
    }
    
    _bstr_t getCaption ( )
    {
        return word->GetCaption ( );
    }
    
    void putCaption (
            _bstr_t prop )
    {
        word->PutCaption (
                prop );
    }

    _bstr_t getPath ( )
    {
        return word->GetPath ( );
    }

    
    VARIANT_BOOL getDisplayScrollBars ( )
    {
        return word->GetDisplayScrollBars ( );
    }
    
    void putDisplayScrollBars (
            VARIANT_BOOL prop )
    {
        word->PutDisplayScrollBars (
                prop );
    }
    
    _bstr_t getStartupPath ( )
    {
        return word->GetStartupPath ( );
    }
    
    void putStartupPath (
            _bstr_t prop )
    {
        word->PutStartupPath (
                prop );
    }
    
    long getBackgroundSavingStatus ( )
    {
        return word->GetBackgroundSavingStatus ( );
    }
    
    long getBackgroundPrintingStatus ( )
    {
        return word->GetBackgroundPrintingStatus ( );
    }
    
    long getLeft ( )
    {
        return word->GetLeft ( );
    }
    
    void putLeft (
            long prop )
    {
        word->PutLeft (
                prop );
    }
    
    long getTop ( )
    {
        return word->GetTop ( );
    }
    
    void putTop (
            long prop )
    {
        word->PutTop (
                prop );
    }
    
    long getWidth ( )
    {
        return word->GetWidth ( );
    }
    
    void putWidth (
            long prop )
    {
        word->PutWidth (
                prop );
    }
    
    long getHeight ( )
    {
        return word->GetHeight ( );
    }
    
    void putHeight (
            long prop )
    {
        word->PutHeight (
                prop );
    }
    
    enum Word::WdWindowState getWindowState ( )
    {
        return word->GetWindowState ( );
    }
    
    void putWindowState (
            enum Word::WdWindowState prop )
    {
        word->PutWindowState (
                prop );
    }
    
    VARIANT_BOOL getDisplayAutoCompleteTips ( )
    {
        return word->GetDisplayAutoCompleteTips ( );
    }
    
    void putDisplayAutoCompleteTips (
            VARIANT_BOOL prop )
    {
        word->PutDisplayAutoCompleteTips (
                prop );
    }
    
    Word::OptionsPtr getOptions ( )
    {
        return word->GetOptions ( );
    }
    
    enum Word::WdAlertLevel getDisplayAlerts ( )
    {
        return word->GetDisplayAlerts ( );
    }
    
    void putDisplayAlerts (
            enum Word::WdAlertLevel prop )
    {
        word->PutDisplayAlerts (
                prop );
    }
    
    Word::DictionariesPtr getCustomDictionaries ( )
    {
        return word->GetCustomDictionaries ( );
    }
    
    _bstr_t getPathSeparator ( )
    {
        return word->GetPathSeparator ( );
    }
    
    void putStatusBar (
            _bstr_t _arg1 )
    {
        word->PutStatusBar (
                _arg1 );
    }
    
    VARIANT_BOOL getMAPIAvailable ( )
    {
        return word->GetMAPIAvailable ( );
    }
    
    VARIANT_BOOL getDisplayScreenTips ( )
    {
        return word->GetDisplayScreenTips ( );
    }
    
    void putDisplayScreenTips (
            VARIANT_BOOL prop )
    {
        word->PutDisplayScreenTips (
                prop );
    }
    
    enum Word::WdEnableCancelKey getEnableCancelKey ( )
    {
        return word-> GetEnableCancelKey ( );
    }
    
    void putEnableCancelKey (
            enum Word::WdEnableCancelKey prop )
    {
        word->PutEnableCancelKey (
                prop );
    }
    
    VARIANT_BOOL getUserControl ( )
    {
        return word->GetUserControl ( );
    }
    
    Office::FileSearchPtr getFileSearch ( )
    {
        return word->GetFileSearch ( );
    }
    
    enum Word::WdMailSystem getMailSystem ( )
    {
        return word->GetMailSystem ( );
    }
    
    _bstr_t getDefaultTableSeparator ( )
    {
        return word->GetDefaultTableSeparator ( );
    }
    
    void putDefaultTableSeparator (
            _bstr_t prop )
    {
        word->PutDefaultTableSeparator (
                prop );
    }
    
    VARIANT_BOOL getShowVisualBasicEditor ( )
    {
        return word->GetShowVisualBasicEditor ( );
    }
    
    void putShowVisualBasicEditor (
            VARIANT_BOOL prop )
    {
        word->PutShowVisualBasicEditor (
                prop );
    }
    
    _bstr_t getBrowseExtraFileTypes ( )
    {
        return word->GetBrowseExtraFileTypes ( );
    }
    
    void putBrowseExtraFileTypes (
            _bstr_t prop )
    {
        word->PutBrowseExtraFileTypes (
                prop );
    }
    
    VARIANT_BOOL getIsObjectValid (
            IDispatch * object )
    {
        return word->GetIsObjectValid (
                object );
    }
   
    Word::HangulHanjaConversionDictionariesPtr getHangulHanjaDictionaries ( )
    {
        return word->GetHangulHanjaDictionaries ( );
    }
    
    Word::MailMessagePtr getMailMessage ( )
    {
        return word->GetMailMessage ( );
    }
    
    VARIANT_BOOL getFocusInMailHeader ( )
    {
        return word->GetFocusInMailHeader ( );
    }
    
    HRESULT quit (
            VARIANT * saveChanges = &vtMissing,
            VARIANT * originalFormat = &vtMissing,
            VARIANT * routeDocument = &vtMissing )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->Quit (
                saveChanges,
                originalFormat,
                routeDocument ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT screenRefresh ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->ScreenRefresh ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT printOutOld (
            VARIANT * background = &vtMissing,
            VARIANT * append = &vtMissing,
            VARIANT * range = &vtMissing,
            VARIANT * outputFileName = &vtMissing,
            VARIANT * from = &vtMissing,
            VARIANT * to = &vtMissing,
            VARIANT * item = &vtMissing,
            VARIANT * copies = &vtMissing,
            VARIANT * pages = &vtMissing,
            VARIANT * pageType = &vtMissing,
            VARIANT * printToFile = &vtMissing,
            VARIANT * collate = &vtMissing,
            VARIANT * fileName = &vtMissing,
            VARIANT * activePrinterMacGX = &vtMissing,
            VARIANT * manualDuplexPrint = &vtMissing )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word-> PrintOutOld (
                background,
                append,
                range,
                outputFileName,
                from,
                to,
                item,
                copies,
                pages,
                pageType,
                printToFile,
                collate,
                fileName,
                activePrinterMacGX,
                manualDuplexPrint ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT lookupNameProperties (
            _bstr_t name ) 
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word-> LookupNameProperties (
                name ))) {    
            throw hr;
        }
        return hr; 
    }

    HRESULT substituteFont (
            _bstr_t unavailableFont,
            _bstr_t substituteFont )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word-> SubstituteFont (
                unavailableFont,
                substituteFont ))) {     
            throw hr;
        }
        return hr; 
    }
    
    VARIANT_BOOL repeat (
            VARIANT * times = &vtMissing )
    {
        return word->Repeat (
                times );
    }
    
    HRESULT ddeExecute (
            long channel,
            _bstr_t command )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->DDEExecute (
                channel,
                command ))) {
            throw hr;
        }
        return hr; 
    }
    
    long ddeInitiate (
            _bstr_t app,
            _bstr_t topic )
    {
        return word->DDEInitiate (
                app,
                topic );
    }
    
    HRESULT ddePoke (
            long channel,
            _bstr_t item,
            _bstr_t data )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->DDEPoke (
                channel,
                item,
                data ))) {
            throw hr;
        }
        return hr; 
    }
    
    _bstr_t ddeRequest (
            long channel,
            _bstr_t item )
    {
        return word-> DDERequest (
                channel,
                item );
    }
    
    HRESULT ddeTerminate (
            long channel )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->DDETerminate (
                channel ))) { 
            throw hr;
        }
        return hr; 
    }
    
    HRESULT ddeTerminateAll ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->DDETerminateAll ( ))) { 
            throw hr;
        }
        return hr; 
    }
    
    long buildKeyCode (
            enum Word::WdKey arg1,
            VARIANT * arg2 = &vtMissing,
            VARIANT * arg3 = &vtMissing,
            VARIANT * arg4 = &vtMissing )
    {
        return word->BuildKeyCode (
                arg1,
                arg2,
                arg3,
                arg4 );
    }
    
    _bstr_t keyString (
            long keyCode,
            VARIANT * keyCode2 = &vtMissing )
    {
        return word->KeyString (
                keyCode,
                keyCode2 );
    }
    
    HRESULT organizerCopy (
            _bstr_t source,
            _bstr_t destination,
            _bstr_t name,
            enum Word::WdOrganizerObject object )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->OrganizerCopy (
                source,
                destination,
                name,
                object ))) {
            throw hr;
        }
        return hr; 
    }

        HRESULT organizerDelete (
            _bstr_t source,
            _bstr_t name,
            enum Word::WdOrganizerObject object )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->OrganizerDelete (
                source,
                name,
                object ))) {    
            throw hr;
        }
        return hr; 
    }
    
    HRESULT organizerRename (
            _bstr_t source,
            _bstr_t name,
            _bstr_t newName,
            enum Word::WdOrganizerObject object )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->OrganizerRename (
                source,
                name,
                newName,
                object ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT addAddress (
            SAFEARRAY** tagID,
            SAFEARRAY** value )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->AddAddress (
                tagID,
                value ))) {
            throw hr;
        }
        return hr; 
    }
    
    _bstr_t getAddress (
            VARIANT * name = &vtMissing,
            VARIANT * addressProperties = &vtMissing,
            VARIANT * useAutoText = &vtMissing,
            VARIANT * displaySelectDialog = &vtMissing,
            VARIANT * selectDialog = &vtMissing,
            VARIANT * checkNamesDialog = &vtMissing,
            VARIANT * recentAddressesChoice = &vtMissing,
            VARIANT * updateRecentAddresses = &vtMissing )
    {
        return word->GetAddress (
                name,
                addressProperties,
                useAutoText,
                displaySelectDialog,
                selectDialog,
                checkNamesDialog,
                recentAddressesChoice,
                updateRecentAddresses );
    }
    
    VARIANT_BOOL checkGrammar (
            _bstr_t string )
    {
        return word->CheckGrammar (
                string );
    }
    
    VARIANT_BOOL checkSpelling (
            _bstr_t sword,
            VARIANT * customDictionary = &vtMissing,
            VARIANT * ignoreUppercase = &vtMissing,
            VARIANT * mainDictionary = &vtMissing,
            VARIANT * customDictionary2 = &vtMissing,
            VARIANT * customDictionary3 = &vtMissing,
            VARIANT * customDictionary4 = &vtMissing,
            VARIANT * customDictionary5 = &vtMissing,
            VARIANT * customDictionary6 = &vtMissing,
            VARIANT * customDictionary7 = &vtMissing,
            VARIANT * customDictionary8 = &vtMissing,
            VARIANT * customDictionary9 = &vtMissing,
            VARIANT * customDictionary10 = &vtMissing )
    {
        return word->CheckSpelling (
                sword,
                customDictionary,
                ignoreUppercase,
                mainDictionary,
                customDictionary2,
                customDictionary3,
                customDictionary4,
                customDictionary5,
                customDictionary6,
                customDictionary7,
                customDictionary8,
                customDictionary9,
                customDictionary10 );
    }
    
    HRESULT resetIgnoreAll ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->ResetIgnoreAll ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    Word::SpellingSuggestionsPtr getSpellingSuggestions (
            _bstr_t sword,
            VARIANT * customDictionary = &vtMissing,
            VARIANT * ignoreUppercase = &vtMissing,
            VARIANT * mainDictionary = &vtMissing,
            VARIANT * suggestionMode = &vtMissing,
            VARIANT * customDictionary2 = &vtMissing,
            VARIANT * customDictionary3 = &vtMissing,
            VARIANT * customDictionary4 = &vtMissing,
            VARIANT * customDictionary5 = &vtMissing,
            VARIANT * customDictionary6 = &vtMissing,
            VARIANT * customDictionary7 = &vtMissing,
            VARIANT * customDictionary8 = &vtMissing,
            VARIANT * customDictionary9 = &vtMissing,
            VARIANT * customDictionary10 = &vtMissing )
    {
        return word->GetSpellingSuggestions (
                sword,
                customDictionary,
                ignoreUppercase,
                mainDictionary,
                suggestionMode,
                customDictionary2,
                customDictionary3,
                customDictionary4,
                customDictionary5,
                customDictionary6,
                customDictionary7,
                customDictionary8,
                customDictionary9,
                customDictionary10 );
    }
    
    HRESULT goBack ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->GoBack ( ))) {    
            throw hr;
        }
        return hr; 
    }
    
    HRESULT help (
            VARIANT * helpType )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->Help (
                helpType ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT automaticChange ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->AutomaticChange ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT showMe ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->ShowMe ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT helpTool ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->HelpTool ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    Word::WindowPtr newWindow ( )
    {
        return word->NewWindow ( );
    }
    
    HRESULT listCommands (
            VARIANT_BOOL listAllCommands )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word-> ListCommands (
                listAllCommands ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT showClipboard ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->ShowClipboard ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT onTime (
            VARIANT * when,
            _bstr_t name,
            VARIANT * tolerance = &vtMissing )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->OnTime (
                when,
                name,
                tolerance ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT nextLetter ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word-> NextLetter ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    short mountVolume (
            _bstr_t zone,
            _bstr_t server,
            _bstr_t volume,
            VARIANT * user = &vtMissing,
            VARIANT * userPassword = &vtMissing,
            VARIANT * volumePassword = &vtMissing )
    {
        return word->MountVolume (
                zone,
                server,
                volume,
                user,
                userPassword,
                volumePassword );
    }
    
    _bstr_t cleanString (
            _bstr_t string )
    {
        return word->CleanString (
                string );
    }
    
    HRESULT sendFax ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->SendFax ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT changeFileOpenDirectory (
            _bstr_t path )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->ChangeFileOpenDirectory (
                path ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT runOld (
            _bstr_t macroName )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->RunOld (
                macroName ))) {    
            throw hr;
        }
        return hr; 
    }
    
    HRESULT goForward ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->GoForward ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT move (
            long left,
            long top )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->Move (
                left,
                top ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT resize (
            long width,
            long height )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->Resize (
                width,
                height ))) {
            throw hr;
        }
        return hr; 
    }
    
    float inchesToPoints (
            float inches )
    {
        return word->InchesToPoints (
                inches );
    }
    
    float centimetersToPoints (
            float centimeters )
    {
        return word->CentimetersToPoints (
                centimeters );
    }
    
    float millimetersToPoints (
            float millimeters )
    {
        return word->MillimetersToPoints (
                millimeters );
    }
    
    float picasToPoints (
            float picas )
    {
        return word->PicasToPoints (
                picas );
    }
    
    float linesToPoints (
            float lines )
    {
        return word->LinesToPoints (
                lines );
    }
    
    float pointsToInches (
            float points )
    {
        return word->PointsToInches (
                points );
    }
    
    float pointsToCentimeters (
            float points )
    {
        return word->PointsToCentimeters (
                points );
    }
    
    float pointsToMillimeters (
            float points )
    {
        return word->PointsToMillimeters (
                points );
    }
    
    float pointsToPicas (
            float points )
    {
        return word->PointsToPicas (
                points );
    }
    
    float pointsToLines (
            float Points )
    {
        return word->PointsToLines (
                Points );
    }
    
    HRESULT activate ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->Activate( ))) {
            throw hr;
        }
        return hr; 
    }
    
    float pointsToPixels (
            float points,
        VARIANT * fVertical = &vtMissing )
    {
        return word->PointsToPixels (
                points,
            fVertical );
    }
    
    float pixelsToPoints (
            float pixels,
            VARIANT * fVertical = &vtMissing )
    {
        return word->PixelsToPoints (
                pixels,
                fVertical );
    }
    
    HRESULT keyboardLatin ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->KeyboardLatin ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT keyboardBidi ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->KeyboardBidi ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT toggleKeyboard ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->ToggleKeyboard ( ))) {
            throw hr;
        }
        return hr; 
    }
    
    long keyboard (
            long langId )
    {
        return word->Keyboard (
                langId ); 
    }
    
    _bstr_t productCode ( )
    {
        return word->ProductCode ( );
    }
    
    Word::DefaultWebOptionsPtr defaultWebOptions ( )
    {
        return word->DefaultWebOptions ( );
    }
    
    HRESULT discussionSupport (
            VARIANT * range,
            VARIANT * cid,
            VARIANT * piCSE )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->DiscussionSupport (
                range,
                cid,
                piCSE ))) {
            throw hr;
        }
        return hr; 
    }
    
    HRESULT setDefaultTheme (
            _bstr_t name,
            enum Word::WdDocumentMedium documentType )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->SetDefaultTheme (
                name,
                documentType ))) {
            throw hr;
        }
        return hr; 
    }
    
    _bstr_t getDefaultTheme (
            enum Word::WdDocumentMedium documentType )
    {
        return word->GetDefaultTheme (
                documentType );
    }
    
    Word::EmailOptionsPtr getEmailOptions ( )
    {
        return word->GetEmailOptions ( );
    }
    
    enum Office::MsoLanguageID getLanguage ( )
    {
        return word->GetLanguage ( );
    }
    
    Office::COMAddInsPtr getCOMAddIns ( )
    {
        return word->GetCOMAddIns ( );
    }
    
    VARIANT_BOOL getCheckLanguage ( )
    {
        return word->GetCheckLanguage ( );
    }
    
    void putCheckLanguage (
            VARIANT_BOOL prop )
    {
        word->PutCheckLanguage (
                prop );
    }
    
    Office::LanguageSettingsPtr getLanguageSettings ( )
    {
        return word->GetLanguageSettings ( );
    }
        
    Office::AnswerWizardPtr getAnswerWizard ( )
    {
        return word->GetAnswerWizard ( );
    }
    
    enum Office::MsoFeatureInstall getFeatureInstall ( )
    {
        return word->GetFeatureInstall ( );
    }
    
    void putFeatureInstall (
            enum Office::MsoFeatureInstall prop )
    {
        word->PutFeatureInstall (
                prop );
    }
    
    HRESULT printOut2000 (
            VARIANT * background = &vtMissing,
            VARIANT * append = &vtMissing,
            VARIANT * range = &vtMissing,
            VARIANT * outputFileName = &vtMissing,
            VARIANT * from = &vtMissing,
            VARIANT * to = &vtMissing,
            VARIANT * item = &vtMissing,
               VARIANT * copies = &vtMissing,
            VARIANT * pages = &vtMissing,
            VARIANT * pageType = &vtMissing,
            VARIANT * printToFile = &vtMissing,
            VARIANT * collate = &vtMissing,
            VARIANT * fileName = &vtMissing,
            VARIANT * activePrinterMacGX = &vtMissing,
            VARIANT * manualDuplexPrint = &vtMissing,
            VARIANT * printZoomColumn = &vtMissing,
            VARIANT * printZoomRow = &vtMissing,
            VARIANT * printZoomPaperWidth = &vtMissing,
            VARIANT * printZoomPaperHeight = &vtMissing )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word-> PrintOut2000 (
                background,
                append,
                range,
                outputFileName,
                from,
                to,
                item,
                   copies,
                pages,
                pageType,
                printToFile,
                collate,
                fileName,
                activePrinterMacGX,
                manualDuplexPrint,
                printZoomColumn,
                printZoomRow,
                printZoomPaperWidth,
                printZoomPaperHeight ))) {
            throw hr;
        }
        return hr; 
    }
    
    _variant_t run (
            _bstr_t macroName,
            VARIANT * varg1 = &vtMissing,
            VARIANT * varg2 = &vtMissing,
            VARIANT * varg3 = &vtMissing,
            VARIANT * varg4 = &vtMissing,
            VARIANT * varg5 = &vtMissing,
            VARIANT * varg6 = &vtMissing,
            VARIANT * varg7 = &vtMissing,
            VARIANT * varg8 = &vtMissing,
            VARIANT * varg9 = &vtMissing,
            VARIANT * varg10 = &vtMissing,
            VARIANT * varg11 = &vtMissing,
            VARIANT * varg12 = &vtMissing,
            VARIANT * varg13 = &vtMissing,
            VARIANT * varg14 = &vtMissing,
            VARIANT * varg15 = &vtMissing,
            VARIANT * varg16 = &vtMissing,
            VARIANT * varg17 = &vtMissing,
            VARIANT * varg18 = &vtMissing,
            VARIANT * varg19 = &vtMissing,
            VARIANT * varg20 = &vtMissing,
            VARIANT * varg21 = &vtMissing,
            VARIANT * varg22 = &vtMissing,
            VARIANT * varg23 = &vtMissing,
            VARIANT * varg24 = &vtMissing,
            VARIANT * varg25 = &vtMissing,
            VARIANT * varg26 = &vtMissing,
            VARIANT * varg27 = &vtMissing,
            VARIANT * varg28 = &vtMissing,
            VARIANT * varg29 = &vtMissing,
            VARIANT * varg30 = &vtMissing )
    {
        return word->Run (
                macroName,
                varg1,
                varg2,
                varg3,
                varg4,
                varg5,
                varg6,
                varg7,
                varg8,
                varg9,
                varg10,
                varg11,
                varg12,
                varg13,
                varg14,
                varg15,
                varg16,
                varg17,
                varg18,
                varg19,
                varg20,
                varg21,
                varg22,
                varg23,
                varg24,
                varg25,
                varg26,
                varg27,
                varg28,
                varg29,
                varg30 );
    }
    
    HRESULT printOut (
            VARIANT * background = &vtMissing,
            VARIANT * append = &vtMissing,
            VARIANT * range = &vtMissing,
            VARIANT * outputFileName = &vtMissing,
            VARIANT * from = &vtMissing,
            VARIANT * to = &vtMissing,
            VARIANT * item = &vtMissing,
            VARIANT * copies = &vtMissing,
            VARIANT * pages = &vtMissing,
            VARIANT * pageType = &vtMissing,
            VARIANT * printToFile = &vtMissing,
            VARIANT * collate = &vtMissing,
            VARIANT * fileName = &vtMissing,
            VARIANT * activePrinterMacGX = &vtMissing,
            VARIANT * manualDuplexPrint = &vtMissing,
            VARIANT * printZoomColumn = &vtMissing,
            VARIANT * printZoomRow = &vtMissing,
            VARIANT * printZoomPaperWidth = &vtMissing,
            VARIANT * printZoomPaperHeight = &vtMissing )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->PrintOut (
                background,
                append,
                range,
                outputFileName,
                from,
                to,
                item,
                copies,
                pages,
                pageType,
                printToFile,
                collate,
                fileName,
                activePrinterMacGX,
                manualDuplexPrint,
                printZoomColumn,
                printZoomRow,
                printZoomPaperWidth,
                printZoomPaperHeight ))) {
    
            throw hr;
        }
        return hr; 
    }
    
    enum Office::MsoAutomationSecurity getAutomationSecurity ( )
    {
        return word->GetAutomationSecurity ( );
    }
    
    void putAutomationSecurity (
            enum Office::MsoAutomationSecurity prop )
    {
        word->PutAutomationSecurity (
                prop );
    }
    
    Office::FileDialogPtr getFileDialog (
            enum Office::MsoFileDialogType fileDialogType )
    {
        return word->GetFileDialog (
                fileDialogType );
    }
    
    _bstr_t getEmailTemplate ( )
    {
        return word->GetEmailTemplate ( );
    }
    
    void putEmailTemplate (
            _bstr_t prop )
    {
        word->PutEmailTemplate (
                prop );
    }
    
    VARIANT_BOOL getShowWindowsInTaskbar ( )
    {
        return word->GetShowWindowsInTaskbar ( );
    }
    
    void putShowWindowsInTaskbar (
            VARIANT_BOOL prop )
    {
        word->PutShowWindowsInTaskbar (
                prop );
    }
    
    Office::NewFilePtr getNewDocument ( )
    {
        return word->GetNewDocument ( );
    }
    
    VARIANT_BOOL getShowStartupDialog ( )
    {
        return word->GetShowStartupDialog ( );
    }
    
    void putShowStartupDialog (
            VARIANT_BOOL prop )
    {
        word->PutShowStartupDialog (
                prop );
    }
    
    Word::AutoCorrectPtr getAutoCorrectEmail ( )
    {
        return word->GetAutoCorrectEmail ( );
    }
    
    Word::TaskPanesPtr getTaskPanes ( )
    {
        return word->GetTaskPanes ( );
    }
    
    VARIANT_BOOL getDefaultLegalBlackline ( )
    {
        return word->GetDefaultLegalBlackline ( );
    }
    
    void putDefaultLegalBlackline (
            VARIANT_BOOL prop )
    {
        word->PutDefaultLegalBlackline (
                prop );
    }
    
    
    Word::SmartTagRecognizersPtr getSmartTagRecognizers ( )
    {
        return word->GetSmartTagRecognizers ( );
    }
    
    Word::SmartTagTypesPtr getSmartTagTypes ( )
    {
        return word->GetSmartTagTypes ( );
    }
    
    Word::XMLNamespacesPtr getXMLNamespaces ( )
    {
        return word->GetXMLNamespaces ( );
    }
    
    HRESULT putFocusInMailHeader ( )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->PutFocusInMailHeader ( ))) {
            throw hr;
        }
        return hr; 
    }
        
    VARIANT_BOOL getArbitraryXMLSupportAvailable ( )
    {
        return word->GetArbitraryXMLSupportAvailable ( );
    }
    
    _bstr_t getBuildFull ( )
    {
        return word->GetBuildFull ( );
    }
    
    _bstr_t getBuildFeatureCrew ( )
    {
        return word->GetBuildFeatureCrew ( );
    }
    
    HRESULT loadMasterList (
            _bstr_t fileName )
    {
        HRESULT hr = S_OK;
        if (FAILED(hr = word->LoadMasterList (
                fileName ))) {
            throw hr;
        }
        return hr; 
    }
    
    Word::_DocumentPtr compareDocuments (
            struct Word::_Document * originalDocument,
            struct Word::_Document * revisedDocument,
            enum Word::WdCompareDestination destination,
            enum Word::WdGranularity granularity,
            VARIANT_BOOL compareFormatting,
            VARIANT_BOOL compareCaseChanges,
            VARIANT_BOOL compareWhitespace,
            VARIANT_BOOL compareTables,
            VARIANT_BOOL compareHeaders,
            VARIANT_BOOL compareFootnotes,
            VARIANT_BOOL compareTextboxes,
            VARIANT_BOOL compareFields,
            VARIANT_BOOL compareComments,
            VARIANT_BOOL compareMoves,
            _bstr_t revisedAuthor,
            VARIANT_BOOL ignoreAllComparisonWarnings )
    {
        return word->CompareDocuments (
                originalDocument,
                revisedDocument,
                destination,
                granularity,
                compareFormatting,
                compareCaseChanges,
                compareWhitespace,
                compareTables,
                compareHeaders,
                compareFootnotes,
                compareTextboxes,
                compareFields,
                compareComments,
                compareMoves,
                revisedAuthor,
                ignoreAllComparisonWarnings );

    }
    
    Word::_DocumentPtr mergeDocuments (
            struct Word::_Document * originalDocument,
            struct Word::_Document * revisedDocument,
            enum Word::WdCompareDestination destination,
            enum Word::WdGranularity granularity,
            VARIANT_BOOL compareFormatting,
            VARIANT_BOOL compareCaseChanges,
            VARIANT_BOOL compareWhitespace,
            VARIANT_BOOL compareTables,
            VARIANT_BOOL compareHeaders,
            VARIANT_BOOL compareFootnotes,
            VARIANT_BOOL compareTextboxes,
            VARIANT_BOOL compareFields,
            VARIANT_BOOL compareComments,
            VARIANT_BOOL compareMoves,
            _bstr_t originalAuthor,
            _bstr_t revisedAuthor,
            enum Word::WdMergeFormatFrom formatFrom )
    {
        return word->MergeDocuments (
                originalDocument,
                revisedDocument,
                destination,
                granularity,
                compareFormatting,
                compareCaseChanges,
                compareWhitespace,
                compareTables,
                compareHeaders,
                compareFootnotes,
                compareTextboxes,
                compareFields,
                compareComments,
                compareMoves,
                originalAuthor,
                revisedAuthor,
                formatFrom );
    }

    
    Word::BibliographyPtr getBibliography ( )
    {
        return word->GetBibliography ( );
    }

    
    VARIANT_BOOL getShowStylePreviews ( )
    {
        return word->GetShowStylePreviews ( );
    }
    
    void putShowStylePreviews (
            VARIANT_BOOL prop )
    {
        word->PutShowStylePreviews (
                prop );
    }
    
    VARIANT_BOOL getRestrictLinkedStyles ( )
    {
        return word->GetRestrictLinkedStyles ( );
    }
    
    void putRestrictLinkedStyles (
            VARIANT_BOOL prop )
    {
        word->PutRestrictLinkedStyles (
                prop );
    }
    
    Word::OMathAutoCorrectPtr getOMathAutoCorrect ( )
    {
        return word->GetOMathAutoCorrect ( );
    }

    
    VARIANT_BOOL getDisplayDocumentInformationPanel ( )
    {
        return word->GetDisplayDocumentInformationPanel ( );
    }
    
    void putDisplayDocumentInformationPanel (
            VARIANT_BOOL prop )
    {
        word->PutDisplayDocumentInformationPanel (
                prop );
    }
    
    Office::IAssistancePtr getAssistance ( )
    {
        return word->GetAssistance ( );
    }
    
    VARIANT_BOOL getOpenAttachmentsInFullScreen ( )
    {
        return word->GetOpenAttachmentsInFullScreen ( );
    }
    
    void putOpenAttachmentsInFullScreen (
            VARIANT_BOOL prop )
    {
        word->PutOpenAttachmentsInFullScreen (
                prop );
    }
    
    long getActiveEncryptionSession ( )
    {
        return word->GetActiveEncryptionSession ( );
    }
    
    VARIANT_BOOL getDontResetInsertionPointProperties ( )
    {
        return word->GetDontResetInsertionPointProperties ( );
    }
    
    void putDontResetInsertionPointProperties (
            VARIANT_BOOL prop )
    {
        word->PutDontResetInsertionPointProperties (
                prop );
    }

};

}