Ссылки (гиперссылки) + картинки в RichEdit

...
public:     
        void __fastcall TForm1::WndProc(Messages::TMessage &Message);
...

__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
   unsigned mask = SendMessage(RichEdit1->Handle, EM_GETEVENTMASK, 0, 0);
   SendMessage(RichEdit1->Handle, EM_SETEVENTMASK, 0, mask | ENM_LINK);
   SendMessage(RichEdit1->Handle, EM_AUTOURLDETECT, true, 0);
   RichEdit1->Text = " http://google.ru" ;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::WndProc(Messages::TMessage &Message)
{
   if(Message.Msg == WM_NOTIFY){
      if(((LPNMHDR)Message.LParam)->code == EN_LINK){
         ENLINK* p = (ENLINK *)Message.LParam;
         if(p->msg == WM_LBUTTONDOWN){
            SendMessage(Form1->RichEdit1->Handle, EM_EXSETSEL, 0, (LPARAM)&(p->chrg));
            ShellExecute(Form1->Handle, "open", Form1->RichEdit1->SelText.c_str(), 0, 0, SW_SHOWNORMAL);
         }
      }
   }
   TForm::WndProc(Message);
}

//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ComCtrls.hpp>
#include <RichEditOLE.h>
#include <RichEditOleCallback.h>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TRichEdit *RichEdit1;
private:    // User declarations
public:     // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
new TIRichEditOle(RichEdit1);
}
//---------------------------------------------------------------------------

#include <RichEditOLE.h>
#include <RichEditOleCallback.h>
 
new TIRichEditOle(RichEdit1);

static void InsertBitmap(IRichEditOle *pRichEditOle, HBITMAP hBitmap);

bool TIRichEditOle::InsertMetaFile(HENHMETAFILE hMF)
{
    HRESULT hr;
 
    //Create structured storage.
    LPLOCKBYTES pLockBytes = NULL;
    hr = CreateILockBytesOnHGlobal(NULL, TRUE, &pLockBytes);
    if (FAILED(hr))
        return FALSE;
 
    LPSTORAGE pStorage;
    hr = StgCreateDocfileOnILockBytes(pLockBytes,
           STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_READWRITE,
           0, &pStorage);
    if (FAILED(hr))
        return FALSE;
 
    TIMFObject *pods = new TIMFObject;
    LPDATAOBJECT lpDataObject;
    hr = pods->QueryInterface(IID_IDataObject, (void **)&lpDataObject);
    if (FAILED(hr))
        return FALSE;
 
    pods->SetMetaFile(hMF);
 
    //Get a pointer to the display site.
    LPOLECLIENTSITE pClientSite;
    hr = FIRichEditOle->GetClientSite(&pClientSite);
    if (FAILED(hr))
        return FALSE;
 
    LPOLEOBJECT pObject;
    CLSID clsid = CLSID_NULL;
 
    //Get the IOleObject interface to the object.
    pObject = pods->GetOleObject(pClientSite, pStorage);
 
    //To ensure that references are counted correctly, notify the object that it is contained.
    OleSetContainedObject(pObject, TRUE);
 
    //Set up object info.
    REOBJECT reobject = { sizeof(REOBJECT)};
    hr = pObject->GetUserClassID(&clsid);
    if (FAILED(hr))
    {
        pObject->Release();
        return FALSE;
    }
 
    reobject.clsid = clsid;
    reobject.cp = REO_CP_SELECTION;
    reobject.dvaspect = DVASPECT_CONTENT;
    reobject.dwFlags = REO_GETMETAFILE; //REO_RESIZABLE | REO_BELOWBASELINE;
    reobject.dwUser = 0;
    reobject.poleobj = pObject;
    reobject.polesite = pClientSite;
    reobject.pstg = pStorage;
    SIZEL sizel = { 0 };
    reobject.sizel = sizel;
 
    //Insert the object.
    hr = FIRichEditOle->InsertObject(&reobject);
 
    //Clean up.
    pods->Release();
    pObject->Release();
    lpDataObject->Release();
    pClientSite->Release();
    pStorage->Release();
    //FIRichEditOle->Release();
    if (FAILED(hr))
        return FALSE;
    else
        return TRUE;
}
//---------------------------------------------------------------------------
void TIMFObject::SetMetaFile(HENHMETAFILE hMF)
{
    FORMATETC formatEtc;
    formatEtc.cfFormat = CF_ENHMETAFILE;    // Clipboard format - MetaFile
    formatEtc.ptd = NULL;                   // Target Device - Screen
    formatEtc.dwAspect = DVASPECT_CONTENT;  // Level of detail - Full content
    formatEtc.lindex = -1;                  // Index - Not applicaple
    formatEtc.tymed = TYMED_ENHMF;          // Storage medium - HMETAFILE handle
 
    STGMEDIUM stgm;
    stgm.tymed = TYMED_ENHMF;               // Storage medium - HMETAFILE handle
    stgm.hEnhMetaFile=hMF;
    stgm.pUnkForRelease = NULL;             // Use ReleaseStgMedium
 
    this->SetData(&formatEtc, &stgm, true);
}
//---------------------------------------------------------------------------
IOleObject *TIMFObject::GetOleObject(IOleClientSite *pOleClientSite, IStorage *pStorage)
{
    SCODE sc;
    IOleObject *pOleObject;
    sc = ::OleCreateStaticFromData(this, IID_IOleObject, OLERENDER_FORMAT,
            &m_fromat, pOleClientSite, pStorage, (void **)&pOleObject);
 
    return pOleObject;
}
//---------------------------------------------------------------------------

class TIMFObject : IDataObject
{
public:
    //static void InsertMetaFile(HENHMETAFILE hMF);
private:
    ULONG   m_ulRefCnt;
    BOOL    m_bRelease;
 
    // The data being bassed to the richedit
    //
    STGMEDIUM m_stgmed;
    FORMATETC m_fromat;
 
public:
    TIMFObject() : m_ulRefCnt(0)
    {
        m_bRelease = FALSE;
    }
    ~TIMFObject()
    {
        if (m_bRelease)
            ::ReleaseStgMedium(&m_stgmed);
    }
    // Methods of the IUnknown interface
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject)
    {
        if (iid == IID_IUnknown || iid == IID_IDataObject)
        {
            *ppvObject = this;
            AddRef();
            return S_OK;
        }
        else
            return E_NOINTERFACE;
    }
    STDMETHOD_(ULONG, AddRef)(void)
    {
        m_ulRefCnt++;
        return m_ulRefCnt;
    }
    STDMETHOD_(ULONG, Release)(void)
    {
        if (--m_ulRefCnt == 0)
        {
            delete this;
        }
 
        return m_ulRefCnt;
    }
    // Methods of the IDataObject Interface
    STDMETHOD(GetData)(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
    {
        HANDLE hDst;
        hDst = ::OleDuplicateData(m_stgmed.hEnhMetaFile, CF_ENHMETAFILE, NULL);
        if (hDst == NULL)
        {
            return E_HANDLE;
        }
 
        pmedium->tymed = TYMED_ENHMF;
        pmedium->hEnhMetaFile = (HENHMETAFILE)hDst;
        pmedium->pUnkForRelease = NULL;
 
        return S_OK;
    }
    STDMETHOD(GetDataHere)(FORMATETC* pformatetc, STGMEDIUM*  pmedium )
    {
        return E_NOTIMPL;
    }
    STDMETHOD(QueryGetData)(FORMATETC*  pformatetc )
    {
        return E_NOTIMPL;
    }
    STDMETHOD(GetCanonicalFormatEtc)(FORMATETC*  pformatectIn ,FORMATETC* pformatetcOut )
    {
        return E_NOTIMPL;
    }
    STDMETHOD(SetData)(FORMATETC* pformatetc , STGMEDIUM*  pmedium , BOOL  fRelease )
    {
        m_fromat = *pformatetc;
        m_stgmed = *pmedium;
 
        return S_OK;
    }
    STDMETHOD(EnumFormatEtc)(DWORD  dwDirection , IEnumFORMATETC**  ppenumFormatEtc )
    {
        return E_NOTIMPL;
    }
    STDMETHOD(DAdvise)(FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
    {
        return E_NOTIMPL;
    }
    STDMETHOD(DUnadvise)(DWORD dwConnection)
    {
        return E_NOTIMPL;
    }
    STDMETHOD(EnumDAdvise)(IEnumSTATDATA **ppenumAdvise)
    {
        return E_NOTIMPL;
    }
    // Some Other helper functions
    void SetMetaFile(HENHMETAFILE hMF);
    IOleObject *GetOleObject(IOleClientSite *pOleClientSite, IStorage *pStorage);
};
//------------------------------------------------------------------------------

TIRichEditOle *RichEditOle1 = new TIRichEditOle(RichEdit1);
RichEditOle1->InsertMetaFile((HENHMETAFILE)MetaFile1->Handle);

bool TIRichEditOle::InsertBitmap(HBITMAP hBitmap) //Моя функция
{
    CImageDataObject::InsertBitmap(FIRichEditOle, hBitmap);
}
 
//////////////////////////////////////////////////////////////////////
// Static member functions
//////////////////////////////////////////////////////////////////////
 
void CImageDataObject::InsertBitmap(IRichEditOle* pRichEditOle, HBITMAP hBitmap)
{
    SCODE sc;
 
    // Get the image data object
    //
    CImageDataObject *pods = new CImageDataObject;
    LPDATAOBJECT lpDataObject;
    pods->QueryInterface(IID_IDataObject, (void **)&lpDataObject);
 
    pods->SetBitmap(hBitmap);
 
    // Get the RichEdit container site
    //
    IOleClientSite *pOleClientSite;
    pRichEditOle->GetClientSite(&pOleClientSite);
 
    // Initialize a Storage Object
    //
    IStorage *pStorage;
 
    LPLOCKBYTES lpLockBytes = NULL;
    sc = ::CreateILockBytesOnHGlobal(NULL, TRUE, &lpLockBytes);
 
    //if (sc != S_OK)
    //  AfxThrowOleException(sc);
    //ASSERT(lpLockBytes != NULL);
 
    sc = ::StgCreateDocfileOnILockBytes(lpLockBytes,
        STGM_SHARE_EXCLUSIVE|STGM_CREATE|STGM_READWRITE, 0, &pStorage);
 
    //if (sc != S_OK)
    //{
    //  VERIFY(lpLockBytes->Release() == 0);
    //  lpLockBytes = NULL;
    //  AfxThrowOleException(sc);
    //}
    //ASSERT(pStorage != NULL);
 
    // The final ole object which will be inserted in the richedit control
    //
    IOleObject *pOleObject;
    pOleObject = pods->GetOleObject(pOleClientSite, pStorage);
 
    // all items are "contained" -- this makes our reference to this object
    //  weak -- which is needed for links to embedding silent update.
    OleSetContainedObject(pOleObject, TRUE);
 
    // Now Add the object to the RichEdit
    //
    REOBJECT reobject;
    ZeroMemory(&reobject, sizeof(REOBJECT));
    reobject.cbStruct = sizeof(REOBJECT);
 
    CLSID clsid;
    sc = pOleObject->GetUserClassID(&clsid);
 
    //if (sc != S_OK)
    //  AfxThrowOleException(sc);
 
    reobject.clsid = clsid;
    reobject.cp = REO_CP_SELECTION;
    reobject.dvaspect = DVASPECT_CONTENT;
    reobject.poleobj = pOleObject;
    reobject.polesite = pOleClientSite;
    reobject.pstg = pStorage;
 
    // Insert the bitmap at the current location in the richedit control
    //
    pRichEditOle->InsertObject(&reobject);
 
    // Release all unnecessary interfaces
    //
    pOleObject->Release();
    pOleClientSite->Release();
    pStorage->Release();
    lpDataObject->Release();
}
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
void CImageDataObject::SetBitmap(HBITMAP hBitmap)
{
    //ASSERT(hBitmap);
 
    STGMEDIUM stgm;
    stgm.tymed = TYMED_GDI;                 // Storage medium = HBITMAP handle
    stgm.hBitmap = hBitmap;
    stgm.pUnkForRelease = NULL;             // Use ReleaseStgMedium
 
    FORMATETC fm;
    fm.cfFormat = CF_BITMAP;                // Clipboard format = CF_BITMAP
    fm.ptd = NULL;                          // Target Device = Screen
    fm.dwAspect = DVASPECT_CONTENT;         // Level of detail = Full content
    fm.lindex = -1;                         // Index = Not applicaple
    fm.tymed = TYMED_GDI;                   // Storage medium = HBITMAP handle
 
    this->SetData(&fm, &stgm, TRUE);
}
//---------------------------------------------------------------------------
IOleObject *CImageDataObject::GetOleObject(IOleClientSite *pOleClientSite, IStorage *pStorage)
{
    //ASSERT(m_stgmed.hBitmap);
 
    SCODE sc;
    IOleObject *pOleObject;
    sc = ::OleCreateStaticFromData(this, IID_IOleObject, OLERENDER_FORMAT,
            &m_fromat, pOleClientSite, pStorage, (void **)&pOleObject);
 
    //if (sc != S_OK)
    //  AfxThrowOleException(sc);
 
    return pOleObject;
}
//---------------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////
// ImageDataObject.h: Impementation for IDataObject Interface to be used
//                       in inserting bitmap to the RichEdit Control.
//
// Author : Hani Atassi  (atassi@arabteam2000.com)
//
// How to use : Just call the static member InsertBitmap with
//              the appropriate parrameters.
//
// Known bugs :
//
//
//////////////////////////////////////////////////////////////////////
 
class CImageDataObject : IDataObject
{
public:
    // This static fumction accepts those parameters:
    // IRichEditOle* : a pointer to IRochEditOle interface for the RichEdit Control
    // HBITMAP : the bitmap handle.
    //
    // After calling the function, it inserts the image in the current
    //    position of the RichEdit
    //
    static void InsertBitmap(IRichEditOle* pRichEditOle, HBITMAP hBitmap);
    //static void InsertBitmap(LPRICHEDITOLE pRichEditOle, HBITMAP hBitmap);
private:
    ULONG   m_ulRefCnt;
    BOOL    m_bRelease;
 
    // The data being bassed to the richedit
    //
    STGMEDIUM m_stgmed;
    FORMATETC m_fromat;
 
public:
    CImageDataObject() : m_ulRefCnt(0)
    {
        m_bRelease = FALSE;
    }
 
    ~CImageDataObject()
    {
        if (m_bRelease)
            ::ReleaseStgMedium(&m_stgmed);
    }
 
    // Methods of the IUnknown interface
    //
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject)
    {
        if (iid == IID_IUnknown || iid == IID_IDataObject)
        {
            *ppvObject = this;
            AddRef();
            return S_OK;
        }
        else
            return E_NOINTERFACE;
    }
    STDMETHOD_(ULONG, AddRef)(void)
    {
        m_ulRefCnt++;
        return m_ulRefCnt;
    }
    STDMETHOD_(ULONG, Release)(void)
    {
        if (--m_ulRefCnt == 0)
        {
            delete this;
        }
 
        return m_ulRefCnt;
    }
 
    // Methods of the IDataObject Interface
    //
    STDMETHOD(GetData)(FORMATETC *pformatetcIn, STGMEDIUM *pmedium) {
        HANDLE hDst;
        hDst = ::OleDuplicateData(m_stgmed.hBitmap, CF_BITMAP, NULL);
        if (hDst == NULL)
        {
            return E_HANDLE;
        }
 
        pmedium->tymed = TYMED_GDI;
        pmedium->hBitmap = (HBITMAP)hDst;
        pmedium->pUnkForRelease = NULL;
 
        return S_OK;
    }
    STDMETHOD(GetDataHere)(FORMATETC* pformatetc, STGMEDIUM*  pmedium ) {
        return E_NOTIMPL;
    }
    STDMETHOD(QueryGetData)(FORMATETC*  pformatetc ) {
        return E_NOTIMPL;
    }
    STDMETHOD(GetCanonicalFormatEtc)(FORMATETC*  pformatectIn ,FORMATETC* pformatetcOut )   {
        return E_NOTIMPL;
    }
    STDMETHOD(SetData)(FORMATETC* pformatetc , STGMEDIUM*  pmedium , BOOL  fRelease ) {
        m_fromat = *pformatetc;
        m_stgmed = *pmedium;
 
        return S_OK;
    }
    STDMETHOD(EnumFormatEtc)(DWORD  dwDirection , IEnumFORMATETC**  ppenumFormatEtc ) {
        return E_NOTIMPL;
    }
    STDMETHOD(DAdvise)(FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink,
        DWORD *pdwConnection) {
        return E_NOTIMPL;
    }
    STDMETHOD(DUnadvise)(DWORD dwConnection) {
        return E_NOTIMPL;
    }
    STDMETHOD(EnumDAdvise)(IEnumSTATDATA **ppenumAdvise) {
        return E_NOTIMPL;
    }
 
    // Some Other helper functions
    //
    void SetBitmap(HBITMAP hBitmap);
    IOleObject *GetOleObject(IOleClientSite *pOleClientSite, IStorage *pStorage);
 
};
//------------------------------------------------------------------------------

STDMETHODIMP TIRichEditOleCallback::GetContextMenu(THIS_ WORD seltype,
    LPOLEOBJECT lpoleobj, CHARRANGE FAR * lpchrg, HMENU FAR * lphmenu)
{
    TPoint point;
    GetCursorPos(&point);
    FRichEdit->PopupMenu->Popup(point.X,point.Y);
    return S_OK; //E_NOTIMPL;
}