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


//2010/04/01
//2010/05/05

#pragma once

#include <sol/office/PowerPointApplet.h>

namespace SOL {

class PowerPointPresentation :public Object {
private:
    PowerPoint::_PresentationPtr presentation;

public:
    PowerPointPresentation(PowerPoint::_PresentationPtr presen)
    :presentation(presen)
    {

    }

public:
    ~PowerPointPresentation()
    {
        presentation = NULL;
    }
/*
public:
    HRESULT close()
    {
        HRESULT hr = presentation->Close();
        presentation = NULL;
        return hr;
    }

public:
    HRESULT save()
    {
        return presentation->Save();
    }
*/
public:    
/*
    HRESULT saveAs (
        _bstr_t fileName,
        enum PowerPoint::PpSaveAsFileType fileFormat,
        enum Office::MsoTriState embedTrueTypeFonts=Office::msoTrue)
    {
    
        return presentation->SaveAs (
            fileName,
            fileFormat,
            embedTrueTypeFonts );

    }

public:
   HRESULT printOut(
        int from,
        int to,
        _bstr_t printToFile,
        int copies,
        enum Office::MsoTriState collate)
   {
       return presentation->PrintOut (
               from,
            to,
            printToFile,
            copies,
            collate );
   }
*/

public:    
    PowerPoint::_ApplicationPtr getApplication ( )
    {
        return presentation->GetApplication ( );
    }    

    IDispatchPtr getParent ( )
    {
        return presentation->GetParent ( );
    }    
    
    PowerPoint::_MasterPtr getSlideMaster ( )
    {
        return presentation->GetSlideMaster ( );
    }    
    
    PowerPoint::_MasterPtr getTitleMaster ( )
    {
        return presentation->GetTitleMaster ( );
    }    
    
    enum Office::MsoTriState getHasTitleMaster ( )
    {
        return presentation->GetHasTitleMaster ( );
    }    
    
    PowerPoint::_MasterPtr addTitleMaster ( )
    {
        return presentation->AddTitleMaster ( );
    }    
    
    HRESULT applyTemplate (
            _bstr_t fileName )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->ApplyTemplate (
                fileName ))) {
            throw hr;
        }
        return hr;
    }    
    
    _bstr_t getTemplateName ( )
    {
        return presentation->GetTemplateName ( );
    }    
    
    PowerPoint::_MasterPtr getNotesMaster ( )
    {
        return presentation->GetNotesMaster ( );
    }    
    
    PowerPoint::_MasterPtr getHandoutMaster ( )
    {
        return presentation->GetHandoutMaster ( );
    }    
    
    PowerPoint::SlidesPtr getSlides ( )
    {
        return presentation->GetSlides ( );
    }    
    
    PowerPoint::PageSetupPtr getPageSetup ( )
    {
        return presentation->GetPageSetup ( );
    }    
    
    PowerPoint::ColorSchemesPtr getColorSchemes ( )
    {
        return presentation->GetColorSchemes ( );
    }    
    
    PowerPoint::ExtraColorsPtr getExtraColors ( )
    {
        return presentation->GetExtraColors ( );
    }    
    
    PowerPoint::SlideShowSettingsPtr getSlideShowSettings ( )
    {
        return presentation->GetSlideShowSettings ( );
    }    
    
    PowerPoint::FontsPtr getFonts ( )
    {
        return presentation->GetFonts ( );
    }    
    
    PowerPoint::DocumentWindowsPtr getWindows ( )
    {
        return presentation->GetWindows ( );
    }    
    
    PowerPoint::TagsPtr getTags ( )
    {
        return presentation->GetTags ( );
    }    
    
    PowerPoint::ShapePtr getDefaultShape ( )
    {
        return presentation->GetDefaultShape ( );
    }    
    
    IDispatchPtr getBuiltInDocumentProperties ( )
    {
        return presentation->GetBuiltInDocumentProperties ( );
    }    
    
    IDispatchPtr getCustomDocumentProperties ( )
    {
        return presentation->GetCustomDocumentProperties ( );
    }    
    
    VBIDE::_VBProjectPtr getVBProject ( )
    {
        return presentation->GetVBProject ( );
    }    

        enum Office::MsoTriState getReadOnly ( )
    {
        return presentation->GetReadOnly ( );
    }    
    
    _bstr_t getFullName ( )
    {
        return presentation->GetFullName ( );
    }    
    
    _bstr_t getName ( )
    {
        return presentation->GetName ( );
    }    
    
    _bstr_t getPath ( )
    {
        return presentation->GetPath ( );
    }    
    
    enum Office::MsoTriState getSaved ( )
    {
        return presentation->GetSaved ( );
    }    
    
    void putSaved (
            enum Office::MsoTriState Saved )
    {
        presentation->PutSaved (
                Saved );
    }    
    
    enum PowerPoint::PpDirection getLayoutDirection ( )
    {
        return presentation->GetLayoutDirection ( );
    }    


        
    void putLayoutDirection (
                enum PowerPoint::PpDirection layoutDirection )
    {
        presentation->PutLayoutDirection (
                layoutDirection );
    }    
    
    PowerPoint::DocumentWindowPtr newWindow ( )
    {
        return presentation->NewWindow ( );
    }    
    
    HRESULT followHyperlink (
            _bstr_t address,
            _bstr_t subAddress,
            VARIANT_BOOL newWindow,
            VARIANT_BOOL addHistory,
            _bstr_t extraInfo,
            enum Office::MsoExtraInfoMethod method,
            _bstr_t headerInfo )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->FollowHyperlink (
                address,
                subAddress,
                newWindow,
                addHistory,
                extraInfo,
                method,
                headerInfo ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT addToFavorites ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->AddToFavorites ( ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT unused ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->Unused ( ))) {
            throw hr;
        }
        return hr;
    }    
    
    PowerPoint::PrintOptionsPtr getPrintOptions ( )
    {
        return presentation->GetPrintOptions ( );
    }    
    
    HRESULT printOut (
            int from,
            int to,
            _bstr_t printToFile,
            int copies,
            enum Office::MsoTriState collate )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->PrintOut (
                from,
                to,
                printToFile,
                copies,
                collate ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT save ( )
    {
        return presentation->Save ( );
    }    
    
/*
enum PpSaveAsFileType
{
    ppSaveAsPresentation = 1,
    ppSaveAsPowerPoint7 = 2,
    ppSaveAsPowerPoint4 = 3,
    ppSaveAsPowerPoint3 = 4,
    ppSaveAsTemplate = 5,
    ppSaveAsRTF = 6,
    ppSaveAsShow = 7,
    ppSaveAsAddIn = 8,
    ppSaveAsPowerPoint4FarEast = 10,
    ppSaveAsDefault = 11,
    ppSaveAsHTML = 12,
    ppSaveAsHTMLv3 = 13,
    ppSaveAsHTMLDual = 14,
    ppSaveAsMetaFile = 15,
    ppSaveAsGIF = 16,
    ppSaveAsJPG = 17,
    ppSaveAsPNG = 18,
    ppSaveAsBMP = 19,
    ppSaveAsWebArchive = 20,
    ppSaveAsTIF = 21,
    ppSaveAsPresForReview = 22,
    ppSaveAsEMF = 23,
    ppSaveAsOpenXMLPresentation = 24,
    ppSaveAsOpenXMLPresentationMacroEnabled = 25,
    ppSaveAsOpenXMLTemplate = 26,
    ppSaveAsOpenXMLTemplateMacroEnabled = 27,
    ppSaveAsOpenXMLShow = 28,
    ppSaveAsOpenXMLShowMacroEnabled = 29,
    ppSaveAsOpenXMLAddin = 30,
    ppSaveAsOpenXMLTheme = 31,
    ppSaveAsPDF = 32,
    ppSaveAsXPS = 33,
    ppSaveAsXMLPresentation = 34,
    ppSaveAsOpenDocumentPresentation = 35,
    ppSaveAsExternalConverter = 36
};

*/

    HRESULT saveAs (
            _bstr_t fileName,
            enum PowerPoint::PpSaveAsFileType fileFormat,
            enum Office::MsoTriState embedTrueTypeFonts=Office::msoTrue )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->SaveAs (
                fileName,
                fileFormat,
                embedTrueTypeFonts ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT saveCopyAs (
            _bstr_t fileName,
            enum PowerPoint::PpSaveAsFileType fileFormat,
            enum Office::MsoTriState embedTrueTypeFonts )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->SaveCopyAs (
                fileName,
                fileFormat,
                embedTrueTypeFonts ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT doExport (
            _bstr_t path,
            _bstr_t filterName,
            int scaleWidth,
            int scaleHeight )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->Export (
                path,
                filterName,
                scaleWidth,
                scaleHeight ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT close ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->Close ( ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT setUndoText (
            _bstr_t text )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->SetUndoText (
                text ))) {
            throw hr;
        }
        return hr;
    }    
    
    IDispatchPtr getContainer ( )
    {
        return presentation->GetContainer ( );
    }    
    
    enum Office::MsoTriState getDisplayComments ( )
    {
        return presentation->GetDisplayComments ( );
    }    
    
    void putDisplayComments (
            enum Office::MsoTriState displayComments )
    {
        presentation->PutDisplayComments (
                displayComments );
    }    
    
    enum PowerPoint::PpFarEastLineBreakLevel getFarEastLineBreakLevel ( )
    {
        return presentation->GetFarEastLineBreakLevel ( );
    }    
    
    void putFarEastLineBreakLevel (
            enum PowerPoint::PpFarEastLineBreakLevel farEastLineBreakLevel )
    {
        presentation->PutFarEastLineBreakLevel (
                farEastLineBreakLevel );
    }    
    
    _bstr_t getNoLineBreakBefore ( )
    {
        return presentation->GetNoLineBreakBefore ( );
    }    
    
    void putNoLineBreakBefore (
            _bstr_t noLineBreakBefore )
    {
        presentation->PutNoLineBreakBefore (
                noLineBreakBefore );
    }    
    
    _bstr_t getNoLineBreakAfter ( )
    {
        return presentation->GetNoLineBreakAfter ( );
    }    
    
    void putNoLineBreakAfter (
            _bstr_t noLineBreakAfter )
    {
        presentation->PutNoLineBreakAfter (
                noLineBreakAfter );
    }    
    
    HRESULT updateLinks ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->UpdateLinks ( ))) {
            throw hr;
        }
        return hr;
    }    
    
    PowerPoint::SlideShowWindowPtr getSlideShowWindow ( )
    {
        return presentation->GetSlideShowWindow ( );
    }    
    
    enum Office::MsoFarEastLineBreakLanguageID getFarEastLineBreakLanguage ( )
    {
        return presentation->GetFarEastLineBreakLanguage ( );
    }    
    
    void putFarEastLineBreakLanguage (
            enum Office::MsoFarEastLineBreakLanguageID farEastLineBreakLanguage )
    {
        presentation->PutFarEastLineBreakLanguage (
                farEastLineBreakLanguage );
    }    
    
    HRESULT webPagePreview ( )    
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->WebPagePreview ( ))) {
            throw hr;
        }
        return hr;
    }    

    enum Office::MsoLanguageID getDefaultLanguageID ( )
    {
        return presentation->GetDefaultLanguageID ( );
    }    
    
    void putDefaultLanguageID (
            enum Office::MsoLanguageID defaultLanguageID )
    {
        presentation->PutDefaultLanguageID (
                defaultLanguageID );
    }    
    
    Office::_CommandBarsPtr getCommandBars ( )
    {
        return presentation->GetCommandBars ( );
    }    
    
    PowerPoint::PublishObjectsPtr getPublishObjects ( )
    {
        return presentation->GetPublishObjects ( );
    }    
    
    PowerPoint::WebOptionsPtr getWebOptions ( )
    {
        return presentation->GetWebOptions ( );
    }    
    
    Office::HTMLProjectPtr getHTMLProject ( )
    {
        return presentation->GetHTMLProject ( );
    }    
    
    HRESULT reloadAs (
            enum Office::MsoEncoding cp )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->ReloadAs (
                cp ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT makeIntoTemplate (
            enum Office::MsoTriState isDesignTemplate )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->MakeIntoTemplate (
                isDesignTemplate ))) {
            throw hr;
        }
        return hr;
    }    
    
    enum Office::MsoTriState getEnvelopeVisible ( )
    {
        return presentation->GetEnvelopeVisible ( );
    }    
    
    void putEnvelopeVisible (
            enum Office::MsoTriState envelopeVisible )
    {
        presentation->PutEnvelopeVisible (
                envelopeVisible );
    }    

        HRESULT sblt (
            _bstr_t s )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->sblt (
                s ))) {
            throw hr;
        }
        return hr;
    }    

        enum Office::MsoTriState getVBASigned ( )
    {
        return presentation->GetVBASigned ( );
    }    

       enum Office::MsoTriState getSnapToGrid ( )
    {
        return presentation->GetSnapToGrid ( );
    }    
    
    void putSnapToGrid (
            enum Office::MsoTriState snapToGrid )
    {
        presentation->PutSnapToGrid (
                snapToGrid );
    }    
    
    float getGridDistance ( )
    {
        return presentation->GetGridDistance ( );
    }    
    
    void putGridDistance (
            float gridDistance )
    {
        return presentation->PutGridDistance (
                gridDistance );
    }    
    
    PowerPoint::DesignsPtr getDesigns ( )
    {
        return presentation->GetDesigns ( );
    }    
    
    HRESULT merge (
            _bstr_t path )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->Merge (
                path ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT checkIn (
            VARIANT_BOOL saveChanges,
            const _variant_t & comments = vtMissing,
            const _variant_t & makePublic = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr =  presentation->CheckIn (
                saveChanges,
                comments,
                makePublic ))) {
            throw hr;
        }
        return hr;
    }    
    
    VARIANT_BOOL canCheckIn ( )
    {
        return presentation->CanCheckIn ( );
    }    
    
    Office::SignatureSetPtr getSignatures ( )
    {
        return presentation->GetSignatures ( );
    }    
    
    enum Office::MsoTriState getRemovePersonalInformation ( )
    {
        return presentation->GetRemovePersonalInformation ( );
    }    
    
    void putRemovePersonalInformation (
        enum Office::MsoTriState removePersonalInformation )
    {
        presentation->PutRemovePersonalInformation (
            removePersonalInformation );
    }    
    
    HRESULT sendForReview (
            _bstr_t recipients,
            _bstr_t subject,
            VARIANT_BOOL showMessage,
            const _variant_t & includeAttachment = vtMissing )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->SendForReview (
                recipients,
                subject,
                showMessage,
                includeAttachment ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT replyWithChanges (
            VARIANT_BOOL showMessage )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->ReplyWithChanges (
                showMessage ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT endReview ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->EndReview ( ))) {
            throw hr;
        }
        return hr;
    }    
    
    enum PowerPoint::PpRevisionInfo getHasRevisionInfo ( )
    {
        return presentation->GetHasRevisionInfo ( );
    }    
    
    HRESULT addBaseline (
            _bstr_t fileName )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->AddBaseline (
                fileName ))) {
            throw hr;
        }
        return hr;
    }    
    
    HRESULT removeBaseline ( )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->RemoveBaseline ( ))) {
            throw hr;
        }
        return hr;
    }    

        _bstr_t getPasswordEncryptionProvider ( )
    {
        return presentation->GetPasswordEncryptionProvider ( );
    }    
    
    _bstr_t getPasswordEncryptionAlgorithm ( )
    {
        return presentation->GetPasswordEncryptionAlgorithm ( );
    }    
    
    int getPasswordEncryptionKeyLength ( )
    {
        return presentation->GetPasswordEncryptionKeyLength ( );
    }    
    
    VARIANT_BOOL getPasswordEncryptionFileProperties ( )
    {
        return presentation->GetPasswordEncryptionFileProperties ( );
    }    
   
     HRESULT setPasswordEncryptionOptions (
            _bstr_t passwordEncryptionProvider,
            _bstr_t passwordEncryptionAlgorithm,
            int passwordEncryptionKeyLength,
            VARIANT_BOOL passwordEncryptionFileProperties )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->SetPasswordEncryptionOptions (
                passwordEncryptionProvider,
                passwordEncryptionAlgorithm,
                passwordEncryptionKeyLength,
                passwordEncryptionFileProperties ))) {
            throw hr;
        }
        return hr;
    }    
    
    _bstr_t getPassword ( )
    {
        return presentation->GetPassword ( );
    }    
    
    void putPassword (
            _bstr_t Password )  
    {
        presentation->PutPassword (
                Password );
    }    

    _bstr_t getWritePassword ( )
    {
        return presentation->GetWritePassword ( );
    }    
    
    void putWritePassword (
            _bstr_t writePassword )
    {
        presentation->PutWritePassword (
                writePassword );
    }    
    
    Office::PermissionPtr getPermission ( )
    {
        return presentation->GetPermission ( );
    }    
    
    Office::SharedWorkspacePtr getSharedWorkspace ( )
    {
        return presentation->GetSharedWorkspace ( );
    }    
    
    Office::SyncPtr getSync ( )
    {
        return presentation->GetSync ( );
    }    
    
    HRESULT sendFaxOverInternet (
            _bstr_t recipients,
            _bstr_t subject,
            VARIANT_BOOL showMessage )
    {
        HRESULT hr = S_OK; 
        if (FAILED(hr = presentation->SendFaxOverInternet (
                recipients,
                subject,
                showMessage ))) {
            throw hr;
        }
        return hr;
    }    
    
    Office::DocumentLibraryVersionsPtr getDocumentLibraryVersions ( )
    {
        return presentation->GetDocumentLibraryVersions ( );
    }    

   
};

}