The Ultimate Toolbox - Updates and User Contributions

void COXPropertiesWnd::FinishEditing(BOOL bSave)
{
	if (m_hEditProp == NULL) {
		return;
	}
	if (bSave)
	{
		// Call OnPropertyValueChanged(...) and save the value
		CString strText;
		COXMaskedEdit* pMaskedEdit = DYNAMIC_DOWNCAST(COXMaskedEdit, m_pEditWnd);
		if (pMaskedEdit != NULL)
			strText = pMaskedEdit->GetText();
		else
			m_pEditWnd->GetWindowText(strText);
		
		BOOL bSaveValue = OnPropertyValueChanged(m_hEditProp,
			GetPropertyValue(m_hEditProp), strText);
		
		if (bSaveValue)
			SetPropertyValue(m_hEditProp, strText);
	}

	// Hide the editor
	m_pEditWnd->ShowWindow(SW_HIDE);
	m_pEditWnd = NULL;
	m_hEditProp = NULL;

	m_wndTree.SelectItem(NULL);
}

void COXPropertyTree::OnKillEditFocus() 
{
    if (m_pPropertiesWnd && m_pPropertiesWnd->m_pEditWnd->IsWindowVisible())
	m_pPropertiesWnd->FinishEditing();
}

BOOL COXBitmapMenuOrganizer::Init(UINT cx, UINT cy, UINT nCheckID, UINT nBulletID)
{
	CDC memDC;
	VERIFY(memDC.CreateCompatibleDC(NULL)); // crash here 
//....
}

 	_TCHAR	*lpszBuffer =
 		(_TCHAR *)LocalAlloc(LMEM_FIXED, (SysStringLen(bstrResult) + 1024)*sizeof(_TCHAR));

	delete [] lpszBuffer;

DWORD COXDragDockContext::CanDock()
{
	BOOL bStyleHorz;
    DWORD dwDock = 0; // Dock Canidate
    DWORD dwCurr = 0; // Current Orientation
	
    // let's check for something in our current orientation first
    // then if the shift key is not forcing our orientation then
    // check for horizontal or vertical orientations as long
    // as we are close enough
    ASSERT(m_dwStyle != 0);
	
    bStyleHorz = HORZF(m_dwStyle);
	
    m_pTargetDockBar = NULL;
	
    // can simplify this, 'cos most of the rectangles are actually the same
    if (dwDock == 0 && HORZF(m_dwDockStyle)/* && m_rectDragHorzAlone.PtInRect(m_ptLast)*/)
	{
        dwDock = m_pDockSite->CanDock(m_rectDragHorzAlone,
			m_dwDockStyle & ~CBRS_ORIENT_VERT, (CDockBar**)&m_pTargetDockBar);
	}
    if (dwDock == 0 && VERTF(m_dwDockStyle)/* && m_rectDragVertAlone.PtInRect(m_ptLast)*/)
	{
        dwDock = m_pDockSite->CanDock(m_rectDragVertAlone,
			m_dwDockStyle & ~CBRS_ORIENT_HORZ, (CDockBar**)&m_pTargetDockBar);
	}
	
	if (dwDock != 0)	// will dock somewhere - now look for 1/2 bars on the row...
	{
		if (HORZF(dwDock))
		{
			m_rectDragDock = m_rectDragHorzAlone;
			dwCurr = m_pDockSite->CanDock(m_rectDragHorz, 
				m_dwDockStyle & ~CBRS_ORIENT_VERT, (CDockBar**)&m_pTargetDockBar);

			if (dwCurr != 0)
			{
				int nBars=m_pTargetDockBar->BarsOnThisRow(m_pBar,m_rectDragHorzAlone);
				if(nBars!=0)
				{
					m_rectDragDock = m_rectDragHorz;

// AAW
					if (m_pBar->m_pDockBar == m_pTargetDockBar)
					{
						// if we're planning to move it to the same bar, don't change our width.
						CRect rct;
						m_pBar->GetWindowRect(&rct);
						m_rectDragDock.bottom = m_rectDragDock.right +
							rct.Width();
					}
					else
// AAW END
					{
						m_rectDragDock.right = m_rectDragDock.left+
							m_rectDragHorzAlone.Width()/(nBars+1);
					}
				}
			}
		}		
		
		if (VERTF(dwDock))
		{
			m_rectDragDock = m_rectDragVertAlone;
			dwCurr = m_pDockSite->CanDock(m_rectDragVert, 
				m_dwDockStyle & ~CBRS_ORIENT_HORZ, (CDockBar**)&m_pTargetDockBar);
			
			if (dwCurr != 0)
			{
				int nBars=m_pTargetDockBar->BarsOnThisRow(m_pBar,m_rectDragVertAlone);
				if(nBars!=0)
				{
					m_rectDragDock = m_rectDragVert;
// AAW
					if (m_pBar->m_pDockBar == m_pTargetDockBar)
					{   // if we're planning to move it to the same bar, don't change our height.
						CRect rct;
						m_pBar->GetWindowRect(&rct);
						m_rectDragDock.bottom = m_rectDragDock.top +
							rct.Height();
					}
					else
// AAW END
					{
						m_rectDragDock.bottom = m_rectDragDock.top+
							m_rectDragVertAlone.Height()/(nBars+1);
					}
				}
			}
		}		
	}

    return dwCurr;
}

int CUGCtrl::StartDragDrop(){
	
	ReleaseCapture();
	
	CString SelectString;
	size_t len;

	CreateSelectedString(SelectString,FALSE);
	len = (SelectString.GetLength()+1) * sizeof(TCHAR);
////////////////////////////////////////////////
// non-unicode *********************************
	HGLOBAL hglobal = GlobalAlloc(GMEM_ZEROINIT,len);
	int res = 1;
    
#	ifdef _UNICODE
    	wchar_t* string = (wchar_t*)GlobalLock(hglobal); 
	
    	memcpy(string, (wchar_t*)SelectString.GetBuffer(), len);

#	else 
		LPTSTR string = (LPTSTR)GlobalLock(hglobal);
		UGStr::tcscpy(string, SelectString.GetLength() + 1, SelectString);
#	endif

////////////////////////////////////////////////////
/////////////// NO CHANGES AFTER THIS    ///////////

	GlobalUnlock(hglobal);
	if(res)	// conversion ok
		m_dataSource.CacheGlobalData(CF_TEXT,hglobal,NULL);

///////////////////////////////////////////////////
// unicode ****************************************

#	ifdef _UNICODE
	HGLOBAL hglobalu = GlobalAlloc(GMEM_ZEROINIT,len);

	LPTSTR stringu = (LPTSTR)GlobalLock(hglobalu);
	UGStr::tcscpy(stringu, SelectString.GetLength() + 1, SelectString);

	GlobalUnlock(hglobalu);
	m_dataSource.CacheGlobalData(CF_UNICODETEXT,hglobalu,NULL);
#	endif



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

	m_dataSource.DoDragDrop(DROPEFFECT_COPY,NULL,NULL);

	m_dataSource.Empty();

	return UG_SUCCESS;
}

int Decode(int index, CUT_DataSource & dest)
int Decode(int index, LPCTSTR filename)

/********************************
EmptyAttachmentList
Deletes all elements in the Attachment List, including
all elements of any include custom header lists.
PARAM:
none
RETURN:
none
*********************************/
void CUT_MimeEncode::EmptyAttachmentList() {

	MIMEATTACHMENTLISTITEM	*item;

	while (m_ptrAttachList != NULL) {
		item = m_ptrAttachList->next;

		if(m_ptrAttachList->ptrDataSource)
			delete m_ptrAttachList->ptrDataSource;

		if (m_ptrAttachList->lpszName  != NULL)
			delete[] m_ptrAttachList->lpszName;

		if (m_ptrAttachList->lpszContentType  != NULL)
			delete[] m_ptrAttachList->lpszContentType;

		if (m_ptrAttachList->lpszCharSet  != NULL)
			delete[] m_ptrAttachList->lpszCharSet;

		if (m_ptrAttachList->lpszAttachType  != NULL)
			delete[] m_ptrAttachList->lpszAttachType;

                /* free memory allocated in AddFileHeaderTag */  
		if(m_ptrAttachList->ptrHeaders)
		{
			m_ptrAttachList->ptrHeaders->ClearList();
			delete m_ptrAttachList->ptrHeaders;
		}

		delete m_ptrAttachList;

		m_ptrAttachList = item;
	}
}

			pItem->lpszName = new char[::strlen(lpszEncoded)];
			::strcpy(pItem->lpszName, lpszEncoded);

			pItem->lpszName = new char[::strlen(lpszEncoded)+1];
			::strcpy(pItem->lpszName, lpszEncoded);

/***********************************************
EncodeAttachmentFileName
Encodes the filename of the attachment
PARAM:
iIndex			- index of the attachment
EncodingType	- encoding algorithm (ENCODING_BASE64 or ENCODING_QUOTED_PRINTABLE)
lpszCharSet		- character set of the header ("utf-8", ...)
RETURN:
UTE_SUCCESS	- success
UTE_ERROR	- error
************************************************/
int CUT_MimeEncode::EncodeAttachmentFileName(int iIndex, enumEncodingType EncodingType, LPCSTR lpszCharSet)
{
	// Loop though all the attachment items and find the one we want
	MIMEATTACHMENTLISTITEM* pItem = m_ptrAttachList;
	int iCount = 0;
	while (pItem != NULL)
	{
		if (iIndex == iCount)
		{
			// Encode this filename
			CUT_HeaderEncoding HE;
			LPCSTR lpszEncoded = HE.Encode(pItem->lpszName, lpszCharSet, EncodingType);
			delete [] pItem->lpszName;
			pItem->lpszName = new char[::strlen(lpszEncoded)+1];
			::strcpy(pItem->lpszName, lpszEncoded);
		}
		pItem = pItem->next;
		iCount++;
	}

	return UTE_SUCCESS;
}

/***********************************************
DecodeAttachmentFileName
Decodes the filename of the attachment
PARAM:
iIndex		- index of the attachment
lpszCharSet	- (out) character set of the decoded text
RETURN:
UTE_SUCCESS	- success
UTE_ERROR	- error
************************************************/
int CUT_MimeEncode::DecodeAttachmentFileName(int iIndex, LPSTR lpszCharSet)
{
	// Loop though all the attachment items and find the one we want
	MIMEATTACHMENTLISTITEM* pItem = m_ptrAttachList;
	int iCount = 0;
	while (pItem != NULL)
	{
		if (iIndex == iCount)
		{
			CUT_HeaderEncoding HE;
			if (HE.IsEncoded(pItem->lpszName))
			{
				// Decode this filename
				LPCSTR lpszDecoded = HE.Decode(pItem->lpszName, lpszCharSet);
				delete [] pItem->lpszName;
				pItem->lpszName = new char[::strlen(lpszDecoded)+1];
				::strcpy(pItem->lpszName, lpszDecoded);
			}
		}
		pItem = pItem->next;
		iCount++;
	}

	return UTE_SUCCESS;
}