#include <IOSTREAM>using namespace std;
#define interface class __declspec(novtable)interface ICodec
{
	public:	virtual bool Decode(char * lpDataSrc,unsigned int nSrcLen,char * lpDataDst,unsigned int *pnDstLen);
	virtual bool Encode(char * lpDataSrc,unsigned int nSrcLen,char * lpDataDst,unsigned int *pnDstLen);
};
class CCodec : public ICodec
{
	public:	virtual bool Decode(char * lpDataSrc,unsigned int nSrcLen,char * lpDataDst,unsigned int *pnDstLen)
 	{
		cout << "解码..." << endl;
		return true;	
	}
	virtual bool Encode(char * lpDataSrc,unsigned int nSrcLen,char * lpDataDst,unsigned int *pnDstLen)	
	{	
		cout << "编码..." << endl;
		return true;	
	}
};
int main(int argc, char* argv[]){
 	ICodec * pCodec = new CCodec();
	pCodec->Decode(NULL,0,NULL,NULL);
	pCodec->Encode(NULL,0,NULL,NULL);
	delete (CCodec*)pCodec;
	return 0;
}
上面的ICodec接口等价于下面的定义：
class ICodec{
public:	virtual bool Decode(char * lpDataSrc,unsigned int nSrcLen,char * lpDataDst,unsigned int *pnDstLen)=0;
virtual bool Encode(char * lpDataSrc,unsigned int nSrcLen,char * lpDataDst,unsigned int *pnDstLen)=0;
};

   // Start Outlook.
   // If it is already running, you'll use the same instance...
   _Application olApp;
   COleException e;
   if(!olApp.CreateDispatch("Outlook.Application", &e)) {
      CString str;
      str.Format("CreateDispatch() failed w/error 0x%08lx", e.m_sc);
      AfxMessageBox(str, MB_SETFOREGROUND);
      return;
   }

   // Logon. Doesn't hurt if you are already running and logged on...
   NameSpace olNs(olApp.GetNamespace("MAPI"));
   COleVariant covOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
   olNs.Logon(covOptional, covOptional, covOptional, covOptional);

   // Create and open a new contact
   _ContactItem olItem(olApp.CreateItem(2));

   // Setup Contact information...
   olItem.SetFullName("James Smith");
   COleDateTime bdDate;
   bdDate.SetDate(1975, 9, 15);
   olItem.SetBirthday(bdDate);
   olItem.SetCompanyName("Microsoft");
   olItem.SetHomeTelephoneNumber("704-555-8888");
   olItem.SetEmail1Address("someone@microsoft.com");
   olItem.SetJobTitle("Developer");
   olItem.SetHomeAddress("111 Main St.\nCharlotte, NC 28226");

   // Save Contact
   olItem.Save();

   // Create a new appointment
   _AppointmentItem olAppt(olApp.CreateItem(1));

   // Schedule it for two minutes from now...
   COleDateTime apptDate = COleDateTime::GetCurrentTime();   
   olAppt.SetStart((DATE)apptDate + DATE(2.0/(24.0*60.0)));

   // Set other appointment info...
   olAppt.SetDuration(60);
   olAppt.SetSubject("Meeting to discuss plans...");

   olAppt.SetBody("Meeting with James to discuss plans.");
   olAppt.SetLocation("Home Office");
   olAppt.SetReminderMinutesBeforeStart(1);
   olAppt.SetReminderSet(TRUE);

   // Save Appointment
   olAppt.Save();

   // Prepare a new mail message
   _MailItem olMail(olApp.CreateItem(0));
   olMail.SetTo("someone@microsoft.com");
   olMail.SetSubject("About our meeting...");
   olMail.SetBody(
      "Hi James,\n\n"
      "\tI'll see you in two minutes for our meeting!\n\n"
      "Btw: I've added you to my contact list!");

   // Send the message!
   olMail.Send();

   AfxMessageBox("All done.", MB_SETFOREGROUND);
   olNs.Logoff();

   #include "msoutl85.h" // for Outlook 2000 use msoutl9.h
                         // for Outlook 2002 & Outlook 2003 use msoutl.h

   // Ole-initialization class.
   class OleInitClass {
   public:
      OleInitClass() {
         OleInitialize(NULL);
      }
      ~OleInitClass() {
         OleUninitialize();
      }
   };
   // This global class calls OleInitialize() at
   // application startup, and calls OleUninitialize()
   // at application exit...
   OleInitClass g_OleInitClass;

Back to the top

Automating Microsoft Outlook 2000, 2002, and 2003

Namespace olNS(olApp.GetNames("MAPI"));

_Namespace olNS(olApp.GetNames("MAPI"));

Set OLNameSP = OL.GetNamespace("MAPI")
Set OLMFolder = OLNameSP.GetDefaultFolder(olFolderInbox)
For i = 1 To OLMFolder.Items.Count
    Set OLMItem = OLMFolder.Items.Item(i)
    Select Case OLMItem.GetInspector.EditorType
        Case olEditorText
            Debug.Print i & "   " & "olEditorText"
'            Debug.Print OLMItem.Body
        Case olEditorHTML
            Debug.Print i & "   " & "olEditorHTML"
'            Debug.Print OLMItem.HTMLBody
        Case olEditorRTF
            Debug.Print i & "   " & "olEditorRTF"
           
        Case olEditorWord
            Debug.Print i & "   " & "olEditorWord"
'            Debug.Print OLMItem.GetInspector.EditorType
        Case Else
            Debug.Print i & "   " & "Unknow"
    End Select
Next

                WideString email;

                email.SetLength(128);
                //emailname.SetLength(128);

                for(int i = 1;i <= count;i++)
                {
                        pList = pAddr->Item(TVariant(i));
                        pAddrEntries = pList->get_AddressEntries();
                        count1 = pAddrEntries->Count;
                        for(int j = 1;j <= count1;j++)
                        {
                                pEntry = pAddrEntries->Item(TVariant(j));
                                //pEntry->get_Name(&emailname);
                                pEntry->get_Address(&email);
                                //this->Memo1->Lines->Add(AnsiString(emailname.c_bstr()) + "\t"+AnsiString(email.c_bstr()));
                                TListItem * ListItem;
                                ListItem = FormList->ListView1->Items->Add();
                                ListItem->Caption = "";
                                ListItem->SubItems->Add(AnsiString(email.c_bstr()));

                                ListItem->Checked = true;
                        }

                }
                ListView1->SetFocus();
                ListView1->Update();
        }
        catch(...)
        {
                try{
                        HRESULT hRes;
                        //LPADRBOOK lpAdrBook;
                        DelphiInterface<IAddrBook>  lpAdrBook;
                //LPWABOBJECT lpWABObject;
                        DelphiInterface<IWABObject>  lpWABObject;
                //LPWAB_PARAM lpWABParam = NULL;
                DWORD Reserved2 = NULL;

                        char szPath[MAX_PATH];
                        SHGetFolderPathX(szPath);
                        char * s = "\\System\\wab32.dll";
                        strcat(szPath, s);

                HINSTANCE hinstLib;
                hinstLib = LoadLibrary(szPath);

               // hinstLib = LoadLibrary(s.c_str()+"\\System\\wab32.dll");
                fWABOpen procWABOpen;

                if (hinstLib != NULL)
                {
                // 获取"Wab32.dll"内部涵数WABOpen的进程地址
                procWABOpen = (fWABOpen) GetProcAddress(hinstLib, "WABOpen");

                if (procWABOpen != NULL)
                {
                hRes = (procWABOpen)(&lpAdrBook,&lpWABObject,NULL,Reserved2);
                //_ASSERTE(hRes == S_OK);
                if (hRes != S_OK)
                                                exit(1);

                ULONG lpcbEntryID;
                ENTRYID *lpEntryID;
                hRes = lpAdrBook->GetPAB(
                &lpcbEntryID,
                &lpEntryID
                        );
                //_ASSERTE(hRes == S_OK);
                if (hRes != S_OK)
                                                exit(2);

                ULONG ulFlags = MAPI_BEST_ACCESS;
                ULONG ulObjType = NULL;
                //LPUNKNOWN lpUnk = NULL;
                                        DelphiInterface<IABContainer>  lpContainer;
                hRes = lpAdrBook->OpenEntry(
                                                lpcbEntryID,
                lpEntryID,
                NULL,
                ulFlags,
                &ulObjType,
                (LPUNKNOWN FAR *)&lpContainer
                        );

                ulFlags = NULL;

                if (ulObjType == MAPI_ABCONT)
                {

                //IABContainer *lpContainer = static_cast <IABContainer *>(lpUnk);

                LPMAPITABLE lpTable = NULL;
                hRes = lpContainer->GetContentsTable(
                ulFlags,
                &lpTable
                        );
                //_ASSERT(lpTable);
                ULONG ulRows;
                hRes = lpTable->GetRowCount(0,&ulRows);
                //_ASSERTE(hRes == S_OK);
                SRowSet *lpRows;

                hRes = lpTable->QueryRows(
                ulRows,// 获取所有行
                0,
                &lpRows
                );
                ListView1->Clear();
                for(ULONG i=0;i<lpRows->cRows;i++)
                {
                SRow *lpRow = &lpRows->aRow[i];
                AnsiString strTemp;

                for(ULONG j=0;j<lpRow->cValues;j++)
                {
                SPropValue *lpProp = &lpRow->lpProps[j];

                if (lpProp->ulPropTag == PR_EMAIL_ADDRESS_A)
                 {
                    TListItem * ListItem;
                    ListItem = FormList->ListView1->Items->Add();
                    ListItem->Caption = "";
                    ListItem->SubItems->Add((char *)lpProp->Value.lpszA);
                //strTemp =(char *)lpProp->Value.lpszA;

                 ListItem->Checked = true;
                                                                }
                }
                //ListEmail->Lines->Add(strTemp);

                lpWABObject->FreeBuffer(lpRow);
                }
                lpWABObject->FreeBuffer(lpRows);
                }
                }
                //FreeLibrary(hinstLib);（装载和释放 dll 文件的地方改成在主程序执行之前装载，结束的时候释放）
                }

使用 Delphi 开发Office Word插件

    在Office 2000中提供了基于COM的插件开发框架，这使得我们可以利用Delphi来扩展Office的功能。

    在Delphi 3,4中编写基于COM的插件，我们需要自己创建COM接口的封装类，更糟糕的是要想支持事件的话还需要使用连接点（connection points）对象来实现事件回调，这是非常麻烦的。但在Delphi 5中这一切就变得非常轻松了，Delphi 5的类型库引入工具提供了/L+的开关，可以自动为我们生成封装好的OLE Server。这下子再也没有什么好抱怨的了。

Office 2000 插件框架

    在Microsoft'的网站上，知识库文章（Knowledge Base article Q230689）中有一篇：Office 2000 COM Add-In Written in Visual C++ 。文章中提供了一个例子(http://support.microsoft.com/download/support/mslfiles/ COMADDIN.EXE)。这篇文章详细地描述了插件框架中的COM接口。仔细研究一下C++代码就可以了解如何编写Office 2000插件。

    Office 2000插件其实就是一个实现了IDTExtensibility2接口的自动化对象。IDTExtensibility2 接口相当简单，插件需要实现接口定义的全部５个函数：

    OnConnection：当应用程序连接到插件时会调用这个函数。插件在函数中接收下列初始化信息——应用程序对象模型进入点的指针，连接模式(是手工加入还是通过命令行载入), 应用程序的对象模型指针和用户自定义的信息。

    OnDisconnection：当应用程序断开插件时被调用，插件应该在这里清除先前分配的资源，删除它添加到应用程序的界面元素。

    OnStartupComplete：这个函数是当应用程序自动启动插件时被调用的。调用时，其他的插件都已经被加载到了内存，这时可以同其他插件进行通信。这个函数还适合添加用户界面元素。

    OnBeginShutdown：当应用程序准备关闭并将要断开插件时会被调用，这时插件应该停止接收用户输入。

    OnAddInsUpdate：当注册的插件列表被改变后会被调用。如果我们的插件不依赖于其他插件，这个函数可以为空。

接口、类型库和常数

    创建插件前，我们需要引入COM对象的接口类型库。这里使用Delphi 5带的TlibImp.exe (Delphi5\Bin目录下)来引入类型库。新版的TlibImp.exe支持新的/L+开关，可以自动创建一个OLE Server的Delphi封装。IDTExtensibility2接口是在MSADDNDR.DLL文件中声明的，位于\Program Files\Common Files\Designer\ 目录下。调用TLIBIMP\L+\Program Files\Common Files\ Designer\MSADDNDR.DLL会生成AddInDesignerObjects_TLB.pas 和 AddInDesignerObjects_TLB.dcr两个文件。在项目的uses部分加上对上面文件的引用以便使用接口。clause of our project to gain access to the interface.使用时注意：TLIBIMP重命名接口为_IDTExtensibility2。

    本文中将使用Word 2000作为例子，如果想编写Outlook、Excel或其他Office程序的插件需要引入相应特定的类型库。比如Word的类型库是定义在\ Program Files\Microsoft Office\Office\MSWORD9.OLB文件中。类似的，Excel、Access和OutLook类型库分别定义在EXCEL9.OLB、 MSACC9.OLB和MSOUTL9.OLB文件中。引入的接口生成在Office_TLB.pas和Word_TLB.pas单元中。

    注意：Office 2000的插件无法工作在Office 97的应用程序中。

最简单的插件

    现在让我们来实现一个最简单的插件，它只实现了IDTExtensibility2接口而没有实现任何比较有意义的功能，但对于演示如何实现插件是一个很好的开始。

    插件可以以进程内或进程外COM服务器的形式实现，在本文中，我们创建的是进程内COM服务器。在Delphi中，选择菜单File | New命令，然后创建一个ActiveX Library，保存生成的文件，再创建一个自动化对象（Automation Object），类名定义为AddIn，把实现单元保存为AddInMain.pas。在AddInMain.pas单元的uses部分添加对 AddinDesignerObjects_TLB，Word_TLB和Office_TLB单元的引用。最后添加 IDTExtensibility2 接口到类定义部分定义类要实现的接口。类定义如下：

    type

      TAddIn = class(TAutoObject, IAddIn, IDTExtensibility2)

    ...

    在类声明的protected部分，添加IDTExtensibility2 接口声明的方法定义，代码示意如下：

    // IDTExtensibility2 methods

    procedure OnConnection(const Application: IDispatch;

      ConnectMode: ext_ConnectMode; const AddInInst: IDispatch;

    var custom: PSafeArray); safecall;

    procedure OnDisconnection(RemoveMode: ext_DisconnectMode;

    var custom: PSafeArray); safecall;

    procedure OnAddInsUpdate(var custom: PSafeArray); safecall;

    procedure OnStartupComplete(var custom: PSafeArray);  safecall;

    procedure OnBeginShutdown(var custom: PSafeArray); safecall;

    使用快捷键[Ctrl][Shift][C]来完成类定义，并添加方法的实现部分的框架到单元中。为了测试插件，可添加下面代码到OnConnection方法中：

    ShowMessage('连接到' + WordApp.Name);

    添加下面代码到OnDisconnection方法的实现部分：

    ShowMessage('断开插件');

    这样就完成了一个最简单的插件了，接下来就是编译并注册插件到Word中去。

注册Office插件

    同其他COM对象一样，一个Office插件必须在系统中注册后才能使用。在Delphi中选择Run | Register ActiveX Server菜单命令，就可以注册我们刚才创建的插件。除了标准的COM注册，还需要进行Office 相关的注册，这需要在注册表中创建一个新的键值：

    HKEY_CURRENT_USER\Software\Microsoft\Office\

      <AppName>\Addins\<AddInProgID>

    <AppName>就是插件宿主应用程序的名字（这里是Word），<AddInProgID>是自动化对象的名字（这里是DIWordAddIn.AddIn，ActiveX library和类名的组合）。

    HKEY_CURRENT_USER \ Software \ Microsoft \ Office \ Word \ Addins\DIWord AddIn.AddIn

    我们还需要在这个键值下创建几个值：一个DWORD类型的名为LoadBehavior的值决定插件是如何加载及被应用程序调用的。在本文中我们设定它为 3–相当于１和２的结合就是应用程序连接插件并在启动时自动加载。值的意义列在表1.2中，各种值可以相互组合。

表1.2

    还有一些其他的值可以出现在注册表键值下，比如定义出现在应用程序COM管理器对话框中的名字，以及设定是否可以从命令行激活插件。

Office 2000用户界面

    Ｏffice应用程序共享一组通用的用户界面元素对象、菜单条、工具条通用控件（比如工具条按钮和组合编辑框）以及Office小助手。

    此前引入的Word类型库就包括了这些通用对象的类型库，但是Delphi引入时并没有像通常那样建立一个封装好的OLE Server，我们不得不手工创建一个Office公开的CommandBarButton对象的Delphi封装。这个对象对应于Office应用程序 的一个简单的菜单项或工具条按钮。

    对大多数的Microsoft的应用程序来说，Application对象代表对象模型的切入点。Office Application类提供了对CommandBars属性的引用。CommandBar对象包括工具条、浮动工具条和菜单。Office对象模型允许 我们创建或更新已有的CommandBars对象。Office_TLB.pas单元包含了ICommandBar接口，它可以被用来修改 CommandBar对象。

    CommandBar有一个Controls集合属性，对应于一组CommandBarControl控件。CommandBarControl控件对应 于放置在工具条上的控件，比如一个CommandBarButton对应一个简单的工具条按钮（或菜单项），CommandBarCombo控件对应组合 编辑框，CommandBarPopup对应于下拉菜单和CommandBarActiveX对应于ActiveX控制。

    在Office_TLB.pas单元中，除了ICommandBarButton接口，还有一个ICommandBarButtonEvents接口用来 提供对工具条上控件的事件支持。事件的支持通常是通过连接点、事件接收连接到可连接对象来实现。但这比较麻烦，我们还可以通过更简单的办法来实现事件支 持。检查一下Delphi在word_tlb.pas单元创建的TWordApplication的实现代码可以发现Delphi封装了每一个可连接对 象，自动实现了事件接收机制。这个单元可以作为一个范本用来创建自定义的对接口对象的封装。

    BtnSvr.pas单元包含了一个手工创建的Delphi封装。除了按标准的Delphi属性方式实现了CommandBarButton对象的属性 外，还实现了InitServerData、InvokeEvent、Connect、ConnectTo和Disconnect方法。可以注意到这部分 完全是模仿TWordApplication实现部分编写的CommandBarButton事件实现。主要就是在InitServerData方法中定 义服务器数据。根据Office_TLB.pas中不同的接口GUID，定义一个CommandBarButton接口的内部的接口Fintf，设定 InvokeEvent方法来激活基于定义在事件接口部分的DispID的Delphi事件支持。最后，Connect、ConnectTo和 Disconnect方法设定Fintf给需要的接口并接收相应的事件。

    定义在BtnSvr.pas单元中的Delphi封装类命名为TButtonServer。它需要从TOleServer对象继承以便支持事件处理。

同应用程序连接

    有了工具条按钮封装类后，接下来要声明一个TWordApplication域来保存对Word Application对象的引用。此外还需要为新的工具条定义一个接口指针以及两个域使用新的TButtonServer类来保存我们要创建的新的工具 条按钮和菜单项。

    在插件类的private部分添加：

    FWordApp : TWordApplication;

    DICommandBar : CommandBar;

    DIBtn : TButtonServer;

    DIMenu : TButtonServer;

    在OnConnection方法中，保存应用程序指针：

    var

      WA : Word_TLB._Application;

    begin

      FWordApp := TWordApplication.Create(nil);

      WA := Application as Word_TLB._Application;

      WordApp.ConnectTo(WA);

      …………………………..

    TWordApplication是Delphi 5中带的Server组件，ConnectTo 方法是用来连接插件和Word提供的接口。因为TWordApplication 把接口事件映射成了Delphi事件，我们可以直接使用标准的Delphi语法来设定事件处理过程。示意如下：

    WordApp.OnEventX := EventXHandler;

    比如我们如果想在Word的选区发生改变时实现某项功能，就可以设定OnWindowSelectionChange 事件。

插件如何创建新的工具条、按钮和菜单

    在创建新的工具条和按钮前，需要为按钮的OnClick过程先创建事件处理函数，下面就是简单的处理函数例子：

    procedure TAddIn.TestClick(const Ctrl: OleVariant;

      var CancelDefault: OleVariant);

    begin

      ShowMessage('有人点我了!');

      CancelDefault := True;

    end;

    CancelDefault参数用来设定是否替代缺省的菜单或工具条按钮的处理过程。这里不需要设定这个参数，因为我们将在插件中创建一个新的按钮。插件 注册为在程序启动时被加载，所以OnStartupComplete方法一定会被调用，用这个方法创建用户界面元素是比较合适的。这里定义BtnIntf 为CommandBarControl接口类型(要创建的CommandBarButton的父类接口)。接下来的任务是确定自定义的工具条是否已经被创 建了

    DICommandBar := nil;

    for i := 1 to WordApp.CommandBars.Count do

      if (WordApp.CommandBars.Item[i].Name ='Delphi') then

        DICommandBar := WordApp.CommandBars.Item[i];

        // 确定是否已经注册了命令条

      if (not Assigned(DICommandBar)) then begin

        DICommandBar:=

WordApp.CommandBars.Add('Delphi',EmptyParam,EmptyParam,EmptyParam);

        DICommandBar.Set_Protection(msoBarNoCustomize)

    end;

    先给工具条起一个唯一的名字“Delphi”，然后在启动时检查工具条是否已经被创建了。如果是的话就把它赋值给DICommandBar，否则调用 Word的CommandBars属性的Add方法创建一个新的工具条。接着给工具条添加msoBarNoCustomize的保护，这可以防止用户添加 或删除工具条上的按钮。这时DICommandBar指向一个有效的工具条，我们可以从接口的Controls集合中获得工具条按钮接口指针。如果工具条 上没有控件，就创建一个新的按钮。

    if (DICommandBar.Controls.Count > 0) then

      BtnIntf := DICommandBar.Controls.Item[1]

     else

      BtnIntf := DICommandBar.Controls.Add(msoControlButton,

      EmptyParam, EmptyParam, EmptyParam, EmptyParam);

    注意：集合中第一项是以1为底的，而不像Delphi中那样通常以0为底。现在我们获得了需要的工具条按钮接口，然后要创建一个基于按钮接口的TButtonServer 类封装。

     DIBtn := TButtonServer.Create(nil);

     DIBtn.ConnectTo(BtnIntf as _CommandBarButton);

     DIBtn.Caption := 'Delphi Test';

     DIBtn.Style := msoButtonCaption;

     DIBtn.Visible := True;

     DIBtn.OnClick := TestClick;

    这里使用ConnectTo 方法连接按钮的事件并设定先前创建的OnClick事件处理过程。最后，要确认使工具条可见。

    DICommandBar.Set_Visible(True);

    TLIBIMP程序创建了一个只读的而非可读写的工具条Visible 属性，但可以使用Set_Visible 方法来设定显示属性（不能生成可读写的属性可能是TLIBIMP的bug）。添加新的菜单项类似于前面，首先创建菜单的OnClick事件处理函数，下面 这个过程遍历被选文本的第一段，并设定其边框样式：

    procedure TAddIn.MenuClick(const Ctrl: OleVariant;

      var CancelDefault: OleVariant);

    var

      Sel : Word_TLB.Selection;

      Par : Word_TLB.Paragraph;

    begin

      Sel := WordApp.ActiveWindow.Selection;

      if (Sel.Type_ in [wdSelectionNormal,

        wdSelectionIP]) then begin

        Par := Sel.Paragraphs.Item(1);

      if (Par.Borders.OutsideLineStyle < wdLineStyleInset) then

        Par.Borders.OutsideLineStyle := 1 + Par.Borders.OutsideLineStyle

      else

        Par.Borders.OutsideLineStyle := wdLineStyleNone;

      end;

    end;

    在OnStartupComplete方法中，添加下面的代码来获得工具菜单的接口指针，查找自定义的的菜单项，如果没有就创建新的，然后设定它的OnClick事件：

    ToolsBar := WordApp.CommandBars['Tools'];

    MenuIntf := ToolsBar.FindControl(EmptyParam, EmptyParam,

      'DIMenu', EmptyParam, EmptyParam);

    if (not Assigned(MenuIntf)) then

      MenuIntf := ToolsBar.Controls.Add(msoControlButton,

      EmptyParam, EmptyParam, EmptyParam, EmptyParam);

      DIMenu := TButtonServer.Create(nil);

      DIMenu.ConnectTo(MenuIntf as _CommandBarButton);

      DIMenu.Caption := 'Delp&hi Menu';

      DIMenu.ShortcutText := '';

      DIMenu.Tag := 'DIMenu';

      DIMenu.Visible := True;

      DIMenu.OnClick := MenuClick;

    CommandBar接口的FindControl方法使用唯一的标识来查找菜单项，如果找到了控件就赋值给 MenuIntf，如果没有找到就创建一个新的菜单项。图1.34显示了自定义的工具条。

清理资源

    注意应该在OnBeginShutdown 方法中清理用户界面元素：

      if (Assigned(DIBtn)) then

      begin

        DIBtn.Free;

        DIBtn := nil;

      end;

      if (Assigned(DIMenu)) then

      begin

        DIMenu.Free;

        DIMenu := nil;

      end;

      if (Assigned(DICommandBar)) then begin

        DICommandBar.Delete;

        DICommandBar := nil;

      end;

    因为插件的框架是通用的，我们可以将同样的OLE Server DLL用于多个应用程序，方法就是确定将激活插件的应用程序，并使用合适的对象模型。最简单的判断方法是在OnConnection中把应用程序的 IDispatch的接口指针赋值给一个OleVariant变量，然后使用相应的Name 属性来确定相应的程序：

    var

      AppVar : OleVariant;

    begin

      AppVar := Application;

      if (AppVar.Name = 'Outlook') then

      begin

        ...

      end

      else if (AppVar.Name = 'Microsoft Word') then

      begin

        ...

      end else ...

    最后，要想获得关于Office开发和Office 2000插件创建更详细的资料，可以查阅microsoft.public.officedev新闻组上的信息。

Microsoft Visual C++ version 5.0 or later has native COM support through the #import statement. Using this statement allows you to automatically add type information contained in a type library into your project. The generated files normally have the same name as the component DLL with the extensions .tlh and .tli.

When using the #import statement, make sure to import the ActiveX Data Objects type information before the Microsoft CDO for Windows 2000 type information. The following examples demonstrate using the #import statement:

#import "c:\program files\common files\system\ado\msado15.dll" no_namespace raw_interfaces_only　rename("EOF", "EndOfFile")#import <cdosys.dll> no_namespace raw_interfaces_only#include "cdosysstr.h"#include "cdosyserr.h"void main() {  CoInitialize(NULL);  IMessage* pMsg = NULL;  HRESULT hr =     CoCreateInstance( __uuidof(Message),                      NULL,                      CLSCTX_INPROC_SERVER,                      __uuidof(IMessage),                     (void**) &pMsg                     );  ...  CoUninitialize();}

Note

You must have the ADO 2.5 type information in the same namespace as CDO type information. CDO interfaces make use of ADO types in arguments. These types are not qualified using namespaces in the CDO interface definitions. If these types are not in the same namespace, errors will occur. You can do one of the following to solve this problem:

• Rename the default ADODB ADO namespace to CDO.
• Import type information into the global namespace, if feasible.
• Rename both CDO and ADODB to another namespace, such as CDOSYS.

The GUID definitions for ADO and CDO types can be retrieved using the __uuidof operator supported by Visual C++. You can use #import flags to specify the CLSID_XXX and IID_XXX definitions if this format is desired.

Consider the following issues when using the #import statement:

1. The header file generated by the #import directive does not contain the module constant definitions contained within the type library. However, the Platform SDK provides two separate headers that can be included within your project so that these constants are available. These files are cdosysstr.h and cdosyserr.h. The first contains the field name constants, and the second includes the CDO custom HRESULT error codes. If you do not include these, you will have to manually insert these values. For example, the field "urn:schemas:httpmail:to" has an associated constant called cdoTo in the string constant header file cdosysstr.h.
2. The #import statement strips the default values for arguments when generating the header files. If you use #import, you will need to explicitly specify the defaults. For example:

   hr = pBp->AddBodyPart(-1); // the -1 is the default value in cdosys.h

Using Interface Pointer Wrapper Classes with Import

The raw_interfaces_only flag to #import directive suppresses the creation of "smart pointer" C++ wrapper classes. However, in many cases these wrappers simplify working with CDO in C++. The following example demonstrates using the wrapper classes produced by the #import statement:

#import "c:\program files\common files\system\ado\msado15.dll" no_namespace　rename("EOF", "EndOfFile")#import <cdosys.dll> no_namespace#include "cdosysstr.h"#include "cdosyserr.h"void main() {  CoInitialize(NULL);  {  try {   IMessagePtr iMsg(__uuidof(Message));   FieldsPtr Flds;   Flds = iMsg->Fields;   Flds->Item[cdoTo]->Value      = _variant_t("example@example.com");   Flds->Item[cdoFrom]->Value    = _variant_t("example@example.com");   Flds->Item[cdoSubject]->Value = _variant_t("a test");   Flds->Item[cdoTextDescription]->Value = _variant_t("this is a test");   Flds->Update();   iMsg->Send();  }  catch( _com_error err) {   //  ... }  }  CoUninitialize();  return 1;}

Using the CDO Namespace

You can use namespaces with the #import statement. However, when you import the ADO type information, you must make sure to add it to the CDO namespace, or suppress the namespace by adding it to the global namespace. If you do not do this, all ADO type information will reside in the ADODB namespace by default, and CDO arguments that are ADO types will not resolve at compile time. The following example demonstrates this:

#import "c:\program files\common files\system\ado\msado15.dll" rename("ADODB","CDO")　rename("EOF", "EndOfFile")#import <cdosys.dll>#include "cdosysstr.h"#include "cdosyserr.h"void main() {  CoInitialize(NULL);  {  try {   CDO::IMessagePtr iMsg(__uuidof(CDO::Message));   CDO::FieldsPtr Flds;   Flds = iMsg->Fields;   Flds->Item[cdoTo]->Value      = _variant_t("example@example.com");   Flds->Item[cdoFrom]->Value    = _variant_t("example@example.com");   Flds->Item[cdoSubject]->Value = _variant_t("a test");   Flds->Item[cdoTextDescription]->Value = _variant_t("this is a test");   Flds->Update();   iMsg->Send();  }  catch( _com_error err) {   //  ...  }}  }  CoUninitialize();  return 1;}

 使用CDO发送邮件

引用CDO组件，SYSTEM32下的CDOSYS。DLL，增加一个包装器

using CDO;

 //本例使用CDO来实现发送邮件，可带验证,此示例在活动目录内向外网发送邮件成功  profession2k office2k office2k3下通过 VS2,2,VS2k3,要引用CDOSYS
   Configuration conf=new Configuration();
   //以下部分设置参数(服务器,端号，用户名，密码，发送邮件帐号，回复邮箱帐号)
   conf.Fields[CdoConfiguration.cdoSendUsingMethod].Value=CdoSendUsing.cdoSendUsingPort;
   conf.Fields[CdoConfiguration.cdoSMTPServer].Value="smtp.21cn.com";
   conf.Fields[CdoConfiguration.cdoSMTPServerPort].Value=25;
   conf.Fields[CdoConfiguration.cdoSMTPAccountName].Value="greystar@21cn.com";
   conf.Fields[CdoConfiguration.cdoSendUserReplyEmailAddress].Value="\"greystar\" <Greystar@skyregister.com>";
   conf.Fields[CdoConfiguration.cdoSendEmailAddress].Value="\"greystar\" <greystar@21cn.com>";
   conf.Fields[CdoConfiguration.cdoSMTPAuthenticate].Value=CdoProtocolsAuthentication.cdoBasic;
   conf.Fields[CdoConfiguration.cdoSendUserName].Value="greystar@21cn.com";
   conf.Fields[CdoConfiguration.cdoSendPassword].Value="XXXXXXX";

   conf.Fields.Update();
   MessageClass msg=new MessageClass();

   msg.Configuration=conf;
  
   msg.To="greystar@21cn.com";
   msg.Subject= "注册确认通知";
   msg.HTMLBody="注册信息"
     msg.From="greystar@21cn.com";

   msg.Send();  

本页

概要

更多信息

自动化和 COM

从 Visual C++ 使用自动化的三种方法

如何使用 Office 类型库

使嵌入的 Office 组件自动运行

参考

概要

您可以使用自动化功能从 Visual C++ 应用程序中控制 Microsoft Office 组件。本文提供使 Office 自动运行所需的基本信息以及指向相关资源和示例代码的指针。

回到顶端

更多信息

回到顶端

自动化和 COM

回到顶端

从 Visual C++ 使用自动化的三种方法

回到顶端

如何使用 Office 类型库

当软件开发者考虑扩展Microsoft Office时，最常想到方法就是是使用VB了。实际上，用C++和ATL扩展Office是相当容易的。

我将向你演示如何建立项目以及如何把Office插件作为COM对象注册到Office中去。（本文用Outlook来作为插件的主程序。）

项目的建立

让我们建立一个新的ATL项目。首先，添加一个叫着Plugin的简单COM对象。用类向导把_IDTExtensibility2接口添加到Plugin类中。（别忘了选中IsupportErrorInfo复选框。）

类向导会把下述方法添加到Plugin类中：OnConnection、OnDisconnection、OnAddinsUpdate、 OnStartupComplete、OnBeginShutdown。本文只处理OnConnection和OnDisconnection方法。

然后，在Plugin头文件中创建一个类型定义（typedef，它只是用来简化代码的），如下所示：

#define APPID 102
class CPlugin;
typedef IDispEventImpl<APPID, CPlugin, &DIID_ApplicationEvents,
&LIBID_Outlook,9,0> OutLookSink;

我们现在需要在Plugin类的继承列表中添加OutLookSink类：

class ATL_NO_VTABLE CPlugin :
       public IPlugin,
       public IDispatchImpl<_IDTExtensibility2, &__uuidof(_IDTExtensibility2),
               &LIBID_AddInDesignerObjects, /* wMajor = */ 1, /* wMinor = */ 0>,
    public OutLookSink

在Plugin.h文件中为Mso9.dll和Msoutl9.olb引入声明，如下所示：

#import "C:\Program Files\Common Files\Designer\msaddndr.dll" \
raw_interfaces_only, \
raw_native_types, no_namespace, named_guids, auto_search

#import "C:\Program Files\Microsoft Office\Office\mso9.dll" \
rename_namespace("Office") named_guids

#import "C:\Program Files\Microsoft \
 Office\Office\msoutl9.olb" \
rename_namespace("Outlook"), raw_interfaces_only, \
 named_guids

using namespace Office;
using namespace Outlook;

注意，你需要按照你的系统中的文件路径来修正上面那些被引入文件的路径。

你必须把Office扩展作为COM组件注册到Office中去。Visual C++自动产生.rgs文件来控制COM注册。我们将需要添加额外的项目加到.rgs文件来支持Office的自动注册。

在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office键下，有若干个子键，每一个子键对应于系统中安装的每一个Office应用程序。在这些键中有插件关键字（add-in key）。

为了在Office中注册我们的COM对象，我们需要在插件键中添加新键。在HKEY_CURRENT_USER下同样有对应的树来控制单个用户的插件，而HKEY_LOCAL_MACHINE控制整个机器的插件。

下面是.rgs文件中Outlook的插件注册码：

HKCU
{
    NoRemove Software
    {
        NoRemove Microsoft
        {
            NoRemove Office
            {
                NoRemove Outlook
                {
                    NoRemove Addins
                    {
                        ForceRemove OutlookDemo.Plugin.1
                        {
                            val FriendlyName = s 'Outlook Plugin'
                            val Description = s 'An Outlook plugin'
                            val LoadBehavior = d 3
                            val CommandLineSafe = d 0
                        }
                        
                    }
                }
            }
        }
    }
}

LoadBehavior的值控制了主程序运行后插件的行为。为了让主程序开始运行后插件自动运行，把LoadBehavior的值设置为3。如果想让用户手工载入插件，就把LoadBehavior设置为8。

如果你编译了这个项目，你就有了一个Outlook 插件；这个插件实际上没有做任何事，但是它的确是一个可以工作的插件。

我们现在向这个插件添加一些功能。首先，添加一个新的成员变量：

     _ApplicationPtr m_pApp;

然后设置OnConnection方法：

    STDMETHOD(OnConnection)(LPDISPATCH Application,
                                                            ext_ConnectMode ConnectMode,
                                                            LPDISPATCH AddInInst,
                                                            SAFEARRAY * * custom)
    {
             HRESULT rslt = S_OK;
             try{
                  m_pApp = Application;
                  OutLookSynch::DispEventAdvise(m_pApp);
             }catch(_com_error &e){
                  OutputDebugString(e.ErrorMessage());
                                    rslt = E_UNEXPECTED;                
             }
             return rslt;
    }

再设置与之对应的OnDisconnection方法，如下所示：

    STDMETHOD(OnDisconnection)(ext_DisconnectMode RemoveMode,SAFEARRAY
* * custom)
      {
                 HRESULT rslt = S_OK;
                 try{
                       OutLookSynch::DispEventUnadvise(m_pApp);
                 }catch(_com_error &e){
                       OutputDebugString(e.ErrorMessage());
                       rslt = E_UNEXPECTED;
                 }
                 return rslt;
    }

现在我们可以收到好几种事件，例如，OnNewMail事件。得到事件的信息以及它们的ID的最好方法就是打开MSVC工具菜单上的OLE/COM观察器（viewer）。

1. 进入File菜单并选择View Typelib。
2. 浏览Msoutl9.olb文件。
3. Scroll down ApplicationEvents的dispinterface。注意OnNewMail事件的ID号为0x0000f003.。
4. 向Cplugin类添加一个叫着OnNewMail的方法。
5. 建立一个Sink映射来把OnNewMail方法关联到OnNewMail事件。

    BEGIN_SINK_MAP(CPlugin)
              SINK_ENTRY_EX(APPID, Outlook::DIID_ApplicationEvents, /
0x0000f003, OnNewMail)
    END_SINK_MAP()

现在我们只需要完成OnNewMail事件处理函数了。

    void _stdcall OnNewMail(){
           MessageBox(NULL, "New Mail", NULL, MB_OK);
    }

如果你想消除这些讨厌的弹出式对话框（由该项目所创建），那么最简单方法就是遵循下面的步骤：

1. 进入Outlook的Tools | Options菜单项。
2. 选择Other标签。
3. 点击Advanced Options按钮。
4. 点击COM 的插件按钮。
5. 选中Outlook的Plugin项并点击Remove。