msppt9.tli

让powerpoint支持插入internet资源

    IDispatch * _result;
    HRESULT _hr = get_Parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

#pragma implementation_key(95)
inline HRESULT MSPPT::Selection::Cut ( ) {
    HRESULT _hr = raw_Cut();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(96)
inline HRESULT MSPPT::Selection::Copy ( ) {
    HRESULT _hr = raw_Copy();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(97)
inline HRESULT MSPPT::Selection::Delete ( ) {
    HRESULT _hr = raw_Delete();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(98)
inline HRESULT MSPPT::Selection::Unselect ( ) {
    HRESULT _hr = raw_Unselect();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(99)
inline enum PpSelectionType MSPPT::Selection::GetType ( ) {
    enum PpSelectionType _result;
    HRESULT _hr = get_Type(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(100)
inline MSPPT::SlideRangePtr MSPPT::Selection::GetSlideRange ( ) {
    struct SlideRange * _result;
    HRESULT _hr = get_SlideRange(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return SlideRangePtr(_result, false);
}

#pragma implementation_key(101)
inline MSPPT::ShapeRangePtr MSPPT::Selection::GetShapeRange ( ) {
    struct ShapeRange * _result;
    HRESULT _hr = get_ShapeRange(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ShapeRangePtr(_result, false);
}

#pragma implementation_key(102)
inline MSPPT::TextRangePtr MSPPT::Selection::GetTextRange ( ) {
    struct TextRange * _result;
    HRESULT _hr = get_TextRange(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return TextRangePtr(_result, false);
}

//
// interface DocumentWindows wrapper method implementations
//

#pragma implementation_key(103)
inline MSPPT::_ApplicationPtr MSPPT::DocumentWindows::GetApplication ( ) {
    struct _Application * _result;
    HRESULT _hr = get_Application(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _ApplicationPtr(_result, false);
}

#pragma implementation_key(104)
inline IDispatchPtr MSPPT::DocumentWindows::GetParent ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

#pragma implementation_key(105)
inline MSPPT::DocumentWindowPtr MSPPT::DocumentWindows::Item ( int index ) {
    struct DocumentWindow * _result;
    HRESULT _hr = raw_Item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return DocumentWindowPtr(_result, false);
}

#pragma implementation_key(106)
inline HRESULT MSPPT::DocumentWindows::Arrange ( enum PpArrangeStyle arrangeStyle ) {
    HRESULT _hr = raw_Arrange(arrangeStyle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface SlideShowWindows wrapper method implementations
//

#pragma implementation_key(107)
inline MSPPT::_ApplicationPtr MSPPT::SlideShowWindows::GetApplication ( ) {
    struct _Application * _result;
    HRESULT _hr = get_Application(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _ApplicationPtr(_result, false);
}

#pragma implementation_key(108)
inline IDispatchPtr MSPPT::SlideShowWindows::GetParent ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

#pragma implementation_key(109)
inline MSPPT::SlideShowWindowPtr MSPPT::SlideShowWindows::Item ( int index ) {
    struct SlideShowWindow * _result;
    HRESULT _hr = raw_Item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return SlideShowWindowPtr(_result, false);
}

//
// interface DocumentWindow wrapper method implementations
//

#pragma implementation_key(110)
inline MSPPT::_ApplicationPtr MSPPT::DocumentWindow::GetApplication ( ) {
    struct _Application * _result;
    HRESULT _hr = get_Application(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _ApplicationPtr(_result, false);
}

#pragma implementation_key(111)
inline IDispatchPtr MSPPT::DocumentWindow::GetParent ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

#pragma implementation_key(112)
inline MSPPT::SelectionPtr MSPPT::DocumentWindow::GetSelection ( ) {
    struct Selection * _result;
    HRESULT _hr = get_Selection(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return SelectionPtr(_result, false);
}

#pragma implementation_key(113)
inline MSPPT::ViewPtr MSPPT::DocumentWindow::GetView ( ) {
    struct View * _result;
    HRESULT _hr = get_View(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ViewPtr(_result, false);
}

#pragma implementation_key(114)
inline MSPPT::_PresentationPtr MSPPT::DocumentWindow::GetPresentation ( ) {
    struct _Presentation * _result;
    HRESULT _hr = get_Presentation(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _PresentationPtr(_result, false);
}

#pragma implementation_key(115)
inline enum PpViewType MSPPT::DocumentWindow::GetViewType ( ) {
    enum PpViewType _result;
    HRESULT _hr = get_ViewType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(116)
inline void MSPPT::DocumentWindow::PutViewType ( enum PpViewType ViewType ) {
    HRESULT _hr = put_ViewType(ViewType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(117)
inline enum Office::MsoTriState MSPPT::DocumentWindow::GetBlackAndWhite ( ) {
    enum Office::MsoTriState _result;
    HRESULT _hr = get_BlackAndWhite(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(118)
inline void MSPPT::DocumentWindow::PutBlackAndWhite ( enum Office::MsoTriState BlackAndWhite ) {
    HRESULT _hr = put_BlackAndWhite(BlackAndWhite);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(119)
inline enum Office::MsoTriState MSPPT::DocumentWindow::GetActive ( ) {
    enum Office::MsoTriState _result;
    HRESULT _hr = get_Active(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(120)
inline enum PpWindowState MSPPT::DocumentWindow::GetWindowState ( ) {
    enum PpWindowState _result;
    HRESULT _hr = get_WindowState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(121)
inline void MSPPT::DocumentWindow::PutWindowState ( enum PpWindowState WindowState ) {
    HRESULT _hr = put_WindowState(WindowState);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(122)
inline _bstr_t MSPPT::DocumentWindow::GetCaption ( ) {
    BSTR _result;
    HRESULT _hr = get_Caption(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

#pragma implementation_key(123)
inline float MSPPT::DocumentWindow::GetLeft ( ) {
    float _result;
    HRESULT _hr = get_Left(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(124)
inline void MSPPT::DocumentWindow::PutLeft ( float Left ) {
    HRESULT _hr = put_Left(Left);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(125)
inline float MSPPT::DocumentWindow::GetTop ( ) {
    float _result;
    HRESULT _hr = get_Top(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(126)
inline void MSPPT::DocumentWindow::PutTop ( float Top ) {
    HRESULT _hr = put_Top(Top);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(127)
inline float MSPPT::DocumentWindow::GetWidth ( ) {
    float _result;
    HRESULT _hr = get_Width(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(128)
inline void MSPPT::DocumentWindow::PutWidth ( float Width ) {
    HRESULT _hr = put_Width(Width);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(129)
inline float MSPPT::DocumentWindow::GetHeight ( ) {
    float _result;
    HRESULT _hr = get_Height(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(130)
inline void MSPPT::DocumentWindow::PutHeight ( float Height ) {
    HRESULT _hr = put_Height(Height);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(131)
inline HRESULT MSPPT::DocumentWindow::FitToPage ( ) {
    HRESULT _hr = raw_FitToPage();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(132)
inline HRESULT MSPPT::DocumentWindow::Activate ( ) {
    HRESULT _hr = raw_Activate();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(133)
inline HRESULT MSPPT::DocumentWindow::LargeScroll ( int Down, int Up, int ToRight, int ToLeft ) {
    HRESULT _hr = raw_LargeScroll(Down, Up, ToRight, ToLeft);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(134)
inline HRESULT MSPPT::DocumentWindow::SmallScroll ( int Down, int Up, int ToRight, int ToLeft ) {
    HRESULT _hr = raw_SmallScroll(Down, Up, ToRight, ToLeft);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(135)
inline MSPPT::DocumentWindowPtr MSPPT::DocumentWindow::NewWindow ( ) {
    struct DocumentWindow * _result;
    HRESULT _hr = raw_NewWindow(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return DocumentWindowPtr(_result, false);
}

#pragma implementation_key(136)
inline HRESULT MSPPT::DocumentWindow::Close ( ) {
    HRESULT _hr = raw_Close();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

#pragma implementation_key(137)
inline long MSPPT::DocumentWindow::GetHWND ( ) {
    long _result;
    HRESULT _hr = get_HWND(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(138)
inline MSPPT::PanePtr MSPPT::DocumentWindow::GetActivePane ( ) {
    struct Pane * _result;
    HRESULT _hr = get_ActivePane(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return PanePtr(_result, false);
}

#pragma implementation_key(139)
inline MSPPT::PanesPtr MSPPT::DocumentWindow::GetPanes ( ) {
    struct Panes * _result;
    HRESULT _hr = get_Panes(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return PanesPtr(_result, false);
}

#pragma implementation_key(140)
inline long MSPPT::DocumentWindow::GetSplitVertical ( ) {
    long _result;
    HRESULT _hr = get_SplitVertical(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

#pragma implementation_key(141)
inline void MSPPT::DocumentWindow::PutSplitVertical ( long SplitVertical ) {
    HRESULT _hr = put_SplitVertical(SplitVertical);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

#pragma implementation_key(142)
inline long MSPPT::DocumentWindow::GetSplitHorizontal ( ) {
    long _result;
    HRESULT _hr = get_SplitHorizontal(&_result);