C / C++ / MFC

class CImcToolBar : public CToolBar, public CImcMenuDropTarget
{
public:
	CImcToolBar (int nToolResourceID);

protected:
	DECLARE_MESSAGE_MAP();

	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnDestroy( );
	afx_msg void OnBeginDragging ( NMHDR * pNotifyStruct, LRESULT* result );

	virtual BOOL AcceptsMenuDrag (DRAGMENUITEM *dmi);
	virtual CPoint ConstrainDragCoords (CPoint pt);
	virtual DROPEFFECT MenuDragDropped (CPoint pt, DRAGMENUITEM *dmi);

	int m_nToolResourceID;
};

///////////////////////////////////

BEGIN_MESSAGE_MAP(CImcToolBar, CToolBar)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_NOTIFY_REFLECT( TBN_DRAGOUT, OnBeginDragging )
END_MESSAGE_MAP()

CImcToolBar::CImcToolBar (int nToolResourceID)
{
	m_nToolResourceID = nToolResourceID;
	m_deDrag = DROPEFFECT_NONE;
}

///////////////////////////////////////

int CImcToolBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CToolBar::OnCreate(lpCreateStruct) == -1)
		return -1;

	RegisterMenuDragDrop (this, IDB_DRAGTOTOOLBAR, RGB(255,0,255));

	return 0;
}


void CImcToolBar::OnDestroy ()
{
	RevokeDragDrop (m_hWnd);
}

void CImcToolBar::OnBeginDragging ( NMHDR * pNotifyStruct, LRESULT* result )
{
	NMTOOLBARA *nm = (NMTOOLBAR *) pNotifyStruct;
	// nm->iItem; - Button ID.

	CFrameWnd *pFrame = GetDockingFrame ();
	ASSERT(pFrame);
	if (!pFrame)
		return;

	DRAGMENUITEM dmi;
	dmi.nID = dmi.ItemInfo.wID = nm->iItem;
	dmi.nToolbarID = GetDlgCtrlID ();

	UINT nFormat = RegisterClipboardFormat (TEXT("ImcMenuDragData"));
	ASSERT(nFormat);
	if (!nFormat)
		return;

	// Remove toolbutton
	TBBUTTONINFO btnInfo;
	memset (&btnInfo, 0, sizeof (btnInfo));
	btnInfo.cbSize = sizeof (btnInfo);
	btnInfo.dwMask = 0; //TBIF_BYINDEX | TBIF_COMMAND;

	int nItem = SendMessage (TB_GETBUTTONINFO, nm->iItem, (LPARAM)&btnInfo);
	ASSERT(nItem >= 0);
	if (nItem < 0)
		return;
	TBBUTTON btnOld;
	if (!SendMessage (TB_GETBUTTON, nItem, (LPARAM)&btnOld))
		return;
	if (!SendMessage (TB_DELETEBUTTON, nItem))
		return;
	pFrame->RecalcLayout ();
	pFrame->UpdateWindow ();
	
	HANDLE hData = ::GlobalAlloc (GMEM_MOVEABLE | GMEM_SHARE, sizeof (DRAGMENUITEM));
	
	char  *buf = (char*) ::GlobalLock (hData);
	memcpy (buf, &dmi, sizeof (DRAGMENUITEM));
	::GlobalUnlock (hData);
	
	COleDataSource ods;
	CImcDropSource ids;
	ods.CacheGlobalData (nFormat, hData);
	
	DROPEFFECT de = ods.DoDragDrop (DROPEFFECT_COPY | DROPEFFECT_MOVE, NULL, &ids); // | DROPEFFECT_MOVE);

	GlobalFree (hData); // Tidy up after the drag-drop operation.

	if (de == DROPEFFECT_NONE) // Put toolbutton back!
		SendMessage (TB_INSERTBUTTON, nItem, (LPARAM)&btnOld);

	pFrame->RecalcLayout ();
}



BOOL CImcToolBar::AcceptsMenuDrag (DRAGMENUITEM *dmi)
{
	return dmi && !dmi->ItemInfo.hSubMenu;
}

// Show the cursor indicator where we want it to be.
CPoint CImcToolBar::ConstrainDragCoords (CPoint pt)
{
	CRect rcClient;
	GetClientRect (&rcClient);

	// Anchor vertically
	pt.y = m_rcDragImage.Height () / 2;

	// Anchor horizontally
	CRect rcItem (-1,-1,-1,-1);
	for (int nItem = 0; ;nItem++ )
	{
		if (!SendMessage (TB_GETITEMRECT, nItem, (LPARAM)&rcItem))
			break;
		if (rcItem.PtInRect (pt))
			break;
	}

	if (pt.x < rcItem.CenterPoint ().x)
		pt.x = rcItem.left;
	else
		pt.x = rcItem.right;

	pt.y = rcItem.CenterPoint ().y;


	return pt;
}


DROPEFFECT CImcToolBar::MenuDragDropped (CPoint pt, DRAGMENUITEM *dmi)
{
	TBBUTTONARRAY btnArray;

	// Process the (sub)menu to create an array of TBBUTTONs
	int nButtons = dmi->CreateDroppedButtonArray (btnArray, m_nToolResourceID);

	if (!btnArray.GetSize ())  // Empty toolbar, so lets not create it!
		return DROPEFFECT_NONE;


	int nItem, nItemMax = SendMessage (TB_BUTTONCOUNT);
	// Which item are we before / after?
	CRect rcItem (-1,-1,-1,-1);
	for (nItem = 0; ;nItem++ )
	{
		if (!SendMessage (TB_GETITEMRECT, nItem, (LPARAM)&rcItem))
			break;
		if (rcItem.PtInRect (pt))
			break;
	}

	BOOL bBefore = pt.x < rcItem.CenterPoint ().x;

	if (!bBefore && (nItem != nItemMax))
	{
		bBefore = TRUE;
		nItem++;
	}

	while (btnArray.GetSize ())
	{
		if (bBefore)
			SendMessage (TB_INSERTBUTTON, nItem++, (LPARAM) btnArray.GetData ()); // Increment the item, as we've just added one!
		else
			SendMessage (TB_ADDBUTTONS, 1, (LPARAM) btnArray.GetData ());

		btnArray.RemoveAt (0);
	}

	CFrameWnd *pFrame = GetDockingFrame ();
	if (pFrame)
		pFrame->RecalcLayout ();
	
	return (dmi->nToolbarID == GetDlgCtrlID ()) ? DROPEFFECT_MOVE : DROPEFFECT_COPY;
}

{<br />
 bstr_t a(_T("Blah")), b(_T("Blah"));<br />
 Foo(a, b);<br />
}

#include < iostream >
using namespace std;

struct a  // our bstr_t (or rather _bstr_t)
{
 a(){
  cout << "a()" << endl;
  s_=0; }
 
 a(const char*s){
  cout << "a(const char*i)" << endl;
  s_ =(char*) malloc(strlen(s)+1);
  strcpy(s_, s); }
 
 const a& operator= (const a& rhs){
   cout << "operator =" << endl;
   // do nothing. just to show this is not called
   return *this; }
 
 ~a(){
  cout << "~a()" << endl;
  free(s_); }
 operator char* () {return s_;}
private:
 char* s_;
};


typedef char MYCHAR;  // our char -> OLECHAR
typedef MYCHAR* MYCHARPTR; // our OLECHAR* -> BSTR


void func (MYCHARPTR n, MYCHARPTR m)
{
 cout << n << " " << m << endl;
}

int main( void )
{
 func( (MYCHARPTR)"Test cast", (MYCHARPTR)"from const char* to BSTR");
 func( (a)"Test cast", (a)"from const char* to BSTR wrapper class");
 func( a("Test constructing"), a("from const char* to BSTR wrapper class"));
 return 0;
}