C / C++ / MFC

HRESULT CreateShortcut(LPCSTR pszShortcutFile, LPSTR pszLink, 
  LPSTR pszDesc)
{
    HRESULT hres;
    IShellLink* psl;

    // Get a pointer to the IShellLink interface.
    hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
                            IID_IShellLink, &psl);
    if (SUCCEEDED(hres))
    {
       IPersistFile* ppf;

       // Query IShellLink for the IPersistFile interface for 
       // saving the shell link in persistent storage.
       hres = psl->QueryInterface(IID_IPersistFile, &ppf);
       if (SUCCEEDED(hres))
       {   
         WORD wsz[MAX_PATH];

         // Set the path to the shell link target.
         hres = psl->SetPath(pszShortcutFile);

         if (!SUCCEEDED(hres))
           AfxMessageBox("SetPath failed!");

         // Set the description of the shell link.
         hres = psl->SetDescription(pszDesc);

         if (!SUCCEEDED(hres))
           AfxMessageBox("SetDescription failed!");

         // Ensure string is ANSI.
         MultiByteToWideChar(CP_ACP, 0, pszLink, -1, wsz, MAX_PATH);

         // Save the link via the IPersistFile::Save method.
         hres = ppf->Save(wsz, TRUE);
    
         // Release pointer to IPersistFile.
         ppf->Release();
       }
       // Release pointer to IShellLink.
       psl->Release();
    }
    return hres;
}

COMBOBOXEXITEM cbitem;
cbitem.mask = CBEIF_TEXT;
// ... init imax to number of records read
imax = ...;
for (int i = 0; i < imax; i ++)
{	
	cbitem.iItem = i;
	cbitem.pszText = LPSTR_TEXTCALLBACK;
	m_cbx.InsertItem(&cbitem);
}

void CYourDialog::OnGetdispinfoNodeType(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NMCOMBOBOXEX *pNMCBX= (NMCOMBOBOXEX *)pNMHDR;
	// your data from DB is cached in some data structure
	// pNMCBX->ceItem.iItem contains an item number
	// you should use iItem to find the string and
	// store its address in pNMCBX->ceItem.pszText
	pNMCBX->ceItem.pszText = someTable[pNMCBX->ceItem.iItem];
	*pResult = 0;
}

void CRefinementProDoc::OnFileSendMail() 
{
	// we need our own implementation of this as if you try and send a modified document,
	// it changes the name of the active document to afx????.tmp which is what we don't want to happen
	ASSERT_VALID(this);
	ASSERT(_afxIsMailAvail);   // update handler always gets called first
	
	CWaitCursor wait;
	
	_AFX_MAIL_STATE* pMailState = _afxMailState;
	if (pMailState->m_hInstMail == NULL)
		pMailState->m_hInstMail = ::LoadLibraryA("MAPI32.DLL");
	
	if (pMailState->m_hInstMail == NULL)
		{
		AfxMessageBox(AFX_IDP_FAILED_MAPI_LOAD);
		return;
		}
	ASSERT(pMailState->m_hInstMail != NULL);
	
	ULONG (PASCAL *lpfnSendMail)(ULONG, ULONG, MapiMessage*, FLAGS, ULONG);
	(FARPROC&)lpfnSendMail = GetProcAddress(pMailState->m_hInstMail, "MAPISendMail");
	if (lpfnSendMail == NULL)
		{
		AfxMessageBox(AFX_IDP_INVALID_MAPI_DLL);
		return;
		}
	ASSERT(lpfnSendMail != NULL);
	
	TCHAR szTempName[_MAX_PATH];
	TCHAR szPath[_MAX_PATH];
	BOOL bRemoveTemp = FALSE;
	if (m_strPathName.IsEmpty() || IsModified())
		{
		CString	old_filename ;
		CString	old_path ;
		// save to temporary path
		VERIFY(GetTempPath(_countof(szPath), szPath) != 0);
		if (DatasetType == TYPE_DATASET)
			{
			old_filename = pntr->m_Filename ;
			old_path = pntr->m_Path ;
			sprintf(szTempName, "%s%s", szPath, pntr->m_Filename) ;
			}
		else
			{
			old_filename = mpntr->m_Filename ;
			old_path = mpntr->m_Path ;
			sprintf(szTempName, "%s%s", szPath, mpntr->m_Filename) ;
			}
		//VERIFY(GetTempFileName(szPath, _T("afx"), 0, szTempName) != 0);
		
		// save it, but remember original modified flag
		m_sending_as_attachment = TRUE ;				// stops temp doc being added to MRU
		BOOL bModified = IsModified();
		BOOL bResult = DoSave(szTempName, FALSE);
		SetModifiedFlag(bModified);
		if (!bResult)
			{
			TRACE0("Warning: file save failed during File.Send Mail.\n");
			return;
			}
		bRemoveTemp = TRUE;
		m_sending_as_attachment = FALSE ;
		// restore the original filename
		if (DatasetType == TYPE_DATASET)
			{
			pntr->m_Filename = old_filename ;
			pntr->m_Path = old_path ;
			}
		else
			{
			mpntr->m_Filename = old_filename ;
			mpntr->m_Path = old_path ;
			}
		SetPathName(old_path + "\\" + old_filename, FALSE) ;
		}
	else
		{
		// use actual file since it isn't modified
		lstrcpyn(szTempName, m_strPathName, _countof(szTempName));
		}
#ifdef _UNICODE
	char szTempNameA[_MAX_PATH];
	_wcstombsz(szTempNameA, szTempName, _countof(szTempNameA));
#endif
	
	// build an appropriate title for the attachment
	TCHAR szTitle[_MAX_PATH];
	if (!m_strPathName.IsEmpty())
		AfxGetFileName(m_strPathName, szTitle, _countof(szTitle));
	else
		{
		lstrcpyn(szTitle, m_strTitle, _countof(szTitle));
		if (m_strTitle.Find('.') == -1) // no extension
			{
			// append the default suffix if there is one
			CString strExt;
			CDocTemplate* pTemplate = GetDocTemplate();
			if (pTemplate != NULL &&
				pTemplate->GetDocString(strExt, CDocTemplate::filterExt))
				{
				lstrcat(szTitle, strExt);
				}
			}
		}
	
#ifdef _UNICODE
	char szTitleA[_MAX_PATH];
	_wcstombsz(szTitleA, szTitle, _countof(szTitleA));
#endif
	
	// prepare the file description (for the attachment)
	MapiFileDesc *fileDesc;
	int	num_attachments = 1 ;
	if (DatasetType == TYPE_DATASET)
		{
		// single atatchment
		fileDesc = new MapiFileDesc ;
		}
	else
		{
		// MultiSets need to also attach each of th sets in the m_ultiSet
		fileDesc = new MapiFileDesc[1 + mpntr->no_in_use] ;
		num_attachments = 1 + mpntr->no_in_use ;;
		}
	memset(fileDesc, 0, sizeof(MapiFileDesc) * num_attachments);
	fileDesc[0].nPosition = (ULONG)-1;
	char szPathAM[MAX_DATASETS_PER_MULTI][_MAX_PATH];
	char szTitleAM[MAX_DATASETS_PER_MULTI][_MAX_PATH];
#ifdef _UNICODE
	fileDesc[0].lpszPathName = szTempNameA;
	fileDesc[0].lpszFileName = szTitleA;
#else
	fileDesc[0].lpszPathName = szTempName;
	fileDesc[0].lpszFileName = szTitle;
#endif

	// setup the multiset bits in the fileDesc structure
	if (DatasetType == TYPE_MULTISET)
		{
		for (int i = 0 ; i < mpntr->no_in_use ; i++)
			{
			fileDesc[i + 1].nPosition = (ULONG)-1 ;
#ifdef _UNICODE
			CString	temp_string ;
			temp_string = mpntr->pntr[i]->m_Path + "\\" + mpntr->pntr[i]->m_Filename ;
			_wcstombsz(szPathAM[i], temp_string, _countof(temp_string));
			_wcstombsz(szTitleAM[i], mpntr->pntr[i]->m_Filename, _countof(mpntr->pntr[i]->m_Filename));
			fileDesc[i + 1].lpszPathName = szPathAM[i] ;
			fileDesc[i + 1].lpszFileName = szTitleAM[i] ;
#else
			sprintf(szPathAM[i], "%s\\%s", mpntr->pntr[i]->m_Path, mpntr->pntr[i]->m_Filename) ;
			sprintf(szTitleAM[i], "%s", mpntr->pntr[i]->m_Filename) ;
			fileDesc[i + 1].lpszPathName = szPathAM[i] ;
			fileDesc[i + 1].lpszFileName =szTitleAM[i] ;
#endif
			}
		}
	
	// prepare the message (empty with 1 attachment)
	MapiMessage message;
	memset(&message, 0, sizeof(message));
	message.nFileCount = num_attachments;
	message.lpFiles = fileDesc;
	
	// prepare for modal dialog box
	AfxGetApp()->EnableModeless(FALSE);
	HWND hWndTop;
	CWnd* pParentWnd = CWnd::GetSafeOwner(NULL, &hWndTop);
	
	// some extra precautions are required to use MAPISendMail as it
	// tends to enable the parent window in between dialogs (after
	// the login dialog, but before the send note dialog).
	pParentWnd->SetCapture();
	::SetFocus(NULL);
	pParentWnd->m_nFlags |= WF_STAYDISABLED;
	
	int nError = lpfnSendMail(0, (ULONG)pParentWnd->GetSafeHwnd(),
		&message, MAPI_LOGON_UI|MAPI_DIALOG, 0);
	
	// after returning from the MAPISendMail call, the window must
	// be re-enabled and focus returned to the frame to undo the workaround
	// done before the MAPI call.
	::ReleaseCapture();
	pParentWnd->m_nFlags &= ~WF_STAYDISABLED;
	
	pParentWnd->EnableWindow(TRUE);
	::SetActiveWindow(NULL);
	pParentWnd->SetActiveWindow();
	pParentWnd->SetFocus();
	if (hWndTop != NULL)
		::EnableWindow(hWndTop, TRUE);
	AfxGetApp()->EnableModeless(TRUE);
	
	if (nError != SUCCESS_SUCCESS &&
		nError != MAPI_USER_ABORT && nError != MAPI_E_LOGIN_FAILURE)
		{
		AfxMessageBox(AFX_IDP_FAILED_MAPI_SEND);
		}
	delete []fileDesc ;
	
	// remove temporary file, if temporary file was used
	if (bRemoveTemp)
		CFile::Remove(szTempName);
	
	// TODO: Add your command handler code here
	//CDocument::OnFileSendMail() ;	
}