atlmisc.h

// Windows Template Library - WTL version 9.10
// Copyright (C) Microsoft Corporation, WTL Team. All rights reserved.
//
// This file is a part of the Windows Template Library.
// The use and distribution terms for this software are covered by the
// Microsoft Public License (http://opensource.org/licenses/MS-PL)
// which can be found in the file MS-PL.txt at the root folder.

#ifndef __ATLMISC_H__
#define __ATLMISC_H__

#pragma once

#ifndef __ATLAPP_H__
    #error atlmisc.h requires atlapp.h to be included first
#endif


#ifdef _ATL_TMP_NO_CSTRING
  #define _WTL_NO_CSTRING
#endif

#if defined(_WTL_USE_CSTRING) && defined(_WTL_NO_CSTRING)
    #error Conflicting options - both _WTL_USE_CSTRING and _WTL_NO_CSTRING are defined
#endif // defined(_WTL_USE_CSTRING) && defined(_WTL_NO_CSTRING)

#if !defined(_WTL_USE_CSTRING) && !defined(_WTL_NO_CSTRING)
  #define _WTL_USE_CSTRING
#endif // !defined(_WTL_USE_CSTRING) && !defined(_WTL_NO_CSTRING)

#ifndef _WTL_NO_CSTRING
  #if defined(_ATL_USE_CSTRING_FLOAT) && defined(_ATL_MIN_CRT)
    #error Cannot use CString floating point formatting with _ATL_MIN_CRT defined
  #endif // defined(_ATL_USE_CSTRING_FLOAT) && defined(_ATL_MIN_CRT)
#endif // !_WTL_NO_CSTRING


// Classes in this file:
//
// CSize
// CPoint
// CRect
// CString
//
// CRecentDocumentListBase<T, t_cchItemLen, t_nFirstID, t_nLastID>
// CRecentDocumentList
// CFindFile
//
// Global functions:
//   AtlGetStockPen()
//   AtlGetStockBrush()
//   AtlGetStockFont()
//   AtlGetStockPalette()
//
//   AtlCompactPath()


namespace WTL
{

#ifndef _WTL_NO_WTYPES

// forward declarations
class CSize;
class CPoint;
class CRect;

// CSize - Wrapper for Windows SIZE structure.

class CSize : public SIZE
{
public:
// Constructors
    CSize()
    {
        cx = 0;
        cy = 0;
    }

    CSize(int initCX, int initCY)
    {
        cx = initCX;
        cy = initCY;
    }

    CSize(SIZE initSize)
    {
        *(SIZE*)this = initSize;
    }

    CSize(POINT initPt)
    {
        *(POINT*)this = initPt;
    }

    CSize(DWORD dwSize)
    {
        cx = (short)LOWORD(dwSize);
        cy = (short)HIWORD(dwSize);
    }

// Operations
    BOOL operator ==(SIZE size) const
    {
        return (cx == size.cx && cy == size.cy);
    }

    BOOL operator !=(SIZE size) const
    {
        return (cx != size.cx || cy != size.cy);
    }

    void operator +=(SIZE size)
    {
        cx += size.cx;
        cy += size.cy;
    }

    void operator -=(SIZE size)
    {
        cx -= size.cx;
        cy -= size.cy;
    }

    void SetSize(int CX, int CY)
    {
        cx = CX;
        cy = CY;
    }

// Operators returning CSize values
    CSize operator +(SIZE size) const
    {
        return CSize(cx + size.cx, cy + size.cy);
    }

    CSize operator -(SIZE size) const
    {
        return CSize(cx - size.cx, cy - size.cy);
    }

    CSize operator -() const
    {
        return CSize(-cx, -cy);
    }

// Operators returning CPoint values
    CPoint operator +(POINT point) const;
    CPoint operator -(POINT point) const;

// Operators returning CRect values
    CRect operator +(const RECT* lpRect) const;
    CRect operator -(const RECT* lpRect) const;
};


// CPoint - Wrapper for Windows POINT structure.

class CPoint : public POINT
{
public:
// Constructors
    CPoint()
    {
        x = 0;
        y = 0;
    }

    CPoint(int initX, int initY)
    {
        x = initX;
        y = initY;
    }

    CPoint(POINT initPt)
    {
        *(POINT*)this = initPt;
    }

    CPoint(SIZE initSize)
    {
        *(SIZE*)this = initSize;
    }

    CPoint(DWORD dwPoint)
    {
        x = (short)LOWORD(dwPoint);
        y = (short)HIWORD(dwPoint);
    }

// Operations
    void Offset(int xOffset, int yOffset)
    {
        x += xOffset;
        y += yOffset;
    }

    void Offset(POINT point)
    {
        x += point.x;
        y += point.y;
    }

    void Offset(SIZE size)
    {
        x += size.cx;
        y += size.cy;
    }

    BOOL operator ==(POINT point) const
    {
        return (x == point.x && y == point.y);
    }

    BOOL operator !=(POINT point) const
    {
        return (x != point.x || y != point.y);
    }

    void operator +=(SIZE size)
    {
        x += size.cx;
        y += size.cy;
    }

    void operator -=(SIZE size)
    {
        x -= size.cx;
        y -= size.cy;
    }

    void operator +=(POINT point)
    {
        x += point.x;
        y += point.y;
    }

    void operator -=(POINT point)
    {
        x -= point.x;
        y -= point.y;
    }

    void SetPoint(int X, int Y)
    {
        x = X;
        y = Y;
    }

// Operators returning CPoint values
    CPoint operator +(SIZE size) const
    {
        return CPoint(x + size.cx, y + size.cy);
    }

    CPoint operator -(SIZE size) const
    {
        return CPoint(x - size.cx, y - size.cy);
    }

    CPoint operator -() const
    {
        return CPoint(-x, -y);
    }

    CPoint operator +(POINT point) const
    {
        return CPoint(x + point.x, y + point.y);
    }

// Operators returning CSize values
    CSize operator -(POINT point) const
    {
        return CSize(x - point.x, y - point.y);
    }

// Operators returning CRect values
    CRect operator +(const RECT* lpRect) const;
    CRect operator -(const RECT* lpRect) const;
};


// CRect - Wrapper for Windows RECT structure.

class CRect : public RECT
{
public:
// Constructors
    CRect()
    {
        left = 0;
        top = 0;
        right = 0;
        bottom = 0;
    }

    CRect(int l, int t, int r, int b)
    {
        left = l;
        top = t;
        right = r;
        bottom = b;
    }

    CRect(const RECT& srcRect)
    {
        ::CopyRect(this, &srcRect);
    }

    CRect(LPCRECT lpSrcRect)
    {
        ::CopyRect(this, lpSrcRect);
    }

    CRect(POINT point, SIZE size)
    {
        right = (left = point.x) + size.cx;
        bottom = (top = point.y) + size.cy;
    }

    CRect(POINT topLeft, POINT bottomRight)
    {
        left = topLeft.x;
        top = topLeft.y;
        right = bottomRight.x;
        bottom = bottomRight.y;
    }

// Attributes (in addition to RECT members)
    int Width() const
    {
        return right - left;
    }

    int Height() const
    {
        return bottom - top;
    }

    CSize Size() const
    {
        return CSize(right - left, bottom - top);
    }

    CPoint& TopLeft()
    {
        return *((CPoint*)this);
    }

    CPoint& BottomRight()
    {
        return *((CPoint*)this + 1);
    }

    const CPoint& TopLeft() const
    {
        return *((CPoint*)this);
    }

    const CPoint& BottomRight() const
    {
        return *((CPoint*)this + 1);
    }

    CPoint CenterPoint() const
    {
        return CPoint((left + right) / 2, (top + bottom) / 2);
    }

    // convert between CRect and LPRECT/LPCRECT (no need for &)
    operator LPRECT()
    {
        return this;
    }

    operator LPCRECT() const
    {
        return this;
    }

    BOOL IsRectEmpty() const
    {
        return ::IsRectEmpty(this);
    }

    BOOL IsRectNull() const
    {
        return (left == 0 && right == 0 && top == 0 && bottom == 0);
    }

    BOOL PtInRect(POINT point) const
    {
        return ::PtInRect(this, point);
    }

// Operations
    void SetRect(int x1, int y1, int x2, int y2)
    {
        ::SetRect(this, x1, y1, x2, y2);
    }

    void SetRect(POINT topLeft, POINT bottomRight)
    {
        ::SetRect(this, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
    }

    void SetRectEmpty()
    {
        ::SetRectEmpty(this);
    }

    void CopyRect(LPCRECT lpSrcRect)
    {
        ::CopyRect(this, lpSrcRect);
    }

    BOOL EqualRect(LPCRECT lpRect) const
    {
        return ::EqualRect(this, lpRect);
    }

    void InflateRect(int x, int y)
    {
        ::InflateRect(this, x, y);
    }

    void InflateRect(SIZE size)
    {
        ::InflateRect(this, size.cx, size.cy);
    }

    void InflateRect(LPCRECT lpRect)
    {
        left -= lpRect->left;
        top -= lpRect->top;
        right += lpRect->right;
        bottom += lpRect->bottom;
    }

    void InflateRect(int l, int t, int r, int b)
    {
        left -= l;
        top -= t;
        right += r;
        bottom += b;
    }

    void DeflateRect(int x, int y)
    {
        ::InflateRect(this, -x, -y);
    }

    void DeflateRect(SIZE size)
    {
        ::InflateRect(this, -size.cx, -size.cy);
    }

    void DeflateRect(LPCRECT lpRect)
    {
        left += lpRect->left;
        top += lpRect->top;
        right -= lpRect->right;
        bottom -= lpRect->bottom;
    }

    void DeflateRect(int l, int t, int r, int b)
    {
        left += l;
        top += t;
        right -= r;
        bottom -= b;
    }

    void OffsetRect(int x, int y)
    {
        ::OffsetRect(this, x, y);
    }
    void OffsetRect(SIZE size)
    {
        ::OffsetRect(this, size.cx, size.cy);
    }

    void OffsetRect(POINT point)
    {
        ::OffsetRect(this, point.x, point.y);
    }

    void NormalizeRect()
    {
        int nTemp;
        if (left > right)
        {
            nTemp = left;
            left = right;
            right = nTemp;
        }
        if (top > bottom)
        {
            nTemp = top;
            top = bottom;
            bottom = nTemp;
        }
    }

    // absolute position of rectangle
    void MoveToY(int y)
    {
        bottom = Height() + y;
        top = y;
    }

    void MoveToX(int x)
    {
        right = Width() + x;
        left = x;
    }

    void MoveToXY(int x, int y)
    {
        MoveToX(x);
        MoveToY(y);
    }

    void MoveToXY(POINT pt)
    {
        MoveToX(pt.x);
        MoveToY(pt.y);
    }

    // operations that fill '*this' with result
    BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2)
    {
        return ::IntersectRect(this, lpRect1, lpRect2);
    }

    BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2)
    {
        return ::UnionRect(this, lpRect1, lpRect2);
    }

    BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2)
    {
        return ::SubtractRect(this, lpRectSrc1, lpRectSrc2);
    }

// Additional Operations
    void operator =(const RECT& srcRect)
    {
        ::CopyRect(this, &srcRect);
    }

    BOOL operator ==(const RECT& rect) const
    {
        return ::EqualRect(this, &rect);
    }

    BOOL operator !=(const RECT& rect) const
    {
        return !::EqualRect(this, &rect);
    }

    void operator +=(POINT point)
    {
        ::OffsetRect(this, point.x, point.y);
    }

    void operator +=(SIZE size)
    {
        ::OffsetRect(this, size.cx, size.cy);
    }

    void operator +=(LPCRECT lpRect)
    {
        InflateRect(lpRect);
    }

    void operator -=(POINT point)
    {
        ::OffsetRect(this, -point.x, -point.y);
    }

    void operator -=(SIZE size)
    {
        ::OffsetRect(this, -size.cx, -size.cy);
    }

    void operator -=(LPCRECT lpRect)
    {
        DeflateRect(lpRect);
    }

    void operator &=(const RECT& rect)
    {
        ::IntersectRect(this, this, &rect);
    }

    void operator |=(const RECT& rect)
    {
        ::UnionRect(this, this, &rect);
    }

// Operators returning CRect values
    CRect operator +(POINT pt) const
    {
        CRect rect(*this);
        ::OffsetRect(&rect, pt.x, pt.y);
        return rect;
    }

    CRect operator -(POINT pt) const
    {
        CRect rect(*this);
        ::OffsetRect(&rect, -pt.x, -pt.y);
        return rect;
    }

    CRect operator +(LPCRECT lpRect) const
    {
        CRect rect(this);
        rect.InflateRect(lpRect);
        return rect;
    }

    CRect operator +(SIZE size) const
    {
        CRect rect(*this);
        ::OffsetRect(&rect, size.cx, size.cy);
        return rect;
    }

    CRect operator -(SIZE size) const
    {
        CRect rect(*this);
        ::OffsetRect(&rect, -size.cx, -size.cy);
        return rect;
    }

    CRect operator -(LPCRECT lpRect) const
    {
        CRect rect(this);
        rect.DeflateRect(lpRect);
        return rect;
    }

    CRect operator &(const RECT& rect2) const
    {
        CRect rect;
        ::IntersectRect(&rect, this, &rect2);
        return rect;
    }

    CRect operator |(const RECT& rect2) const
    {
        CRect rect;
        ::UnionRect(&rect, this, &rect2);
        return rect;
    }

    CRect MulDiv(int nMultiplier, int nDivisor) const
    {
        return CRect(
            ::MulDiv(left, nMultiplier, nDivisor),
            ::MulDiv(top, nMultiplier, nDivisor),
            ::MulDiv(right, nMultiplier, nDivisor),
            ::MulDiv(bottom, nMultiplier, nDivisor));
    }
};


// CSize implementation

inline CPoint CSize::operator +(POINT point) const
{ return CPoint(cx + point.x, cy + point.y); }

inline CPoint CSize::operator -(POINT point) const
{ return CPoint(cx - point.x, cy - point.y); }

inline CRect CSize::operator +(const RECT* lpRect) const
{ return CRect(lpRect) + *this; }

inline CRect CSize::operator -(const RECT* lpRect) const
{ return CRect(lpRect) - *this; }


// CPoint implementation

inline CRect CPoint::operator +(const RECT* lpRect) const
{ return CRect(lpRect) + *this; }

inline CRect CPoint::operator -(const RECT* lpRect) const
{ return CRect(lpRect) - *this; }

#endif // !_WTL_NO_WTYPES


// WTL::CSize or ATL::CSize scalar operators 

#if !defined(_WTL_NO_SIZE_SCALAR) && (!defined(_WTL_NO_WTYPES) || defined(__ATLTYPES_H__))

template <class Num>
inline CSize operator *(SIZE s, Num n) 
{
    return CSize((int)(s.cx * n), (int)(s.cy * n));
};

template <class Num>
inline void operator *=(SIZE & s, Num n)
{
    s = s * n;
};  

template <class Num>
inline CSize operator /(SIZE s, Num n) 
{
    return CSize((int)(s.cx / n), (int)(s.cy / n));
};

template <class Num>
inline void operator /=(SIZE & s, Num n)
{
    s = s / n;
};  

#endif // !defined(_WTL_NO_SIZE_SCALAR) && (!defined(_WTL_NO_WTYPES) || defined(__ATLTYPES_H__))


// CString - String class

#ifndef _WTL_NO_CSTRING

struct CStringData
{
    long nRefs;     // reference count
    int nDataLength;
    int nAllocLength;
    // TCHAR data[nAllocLength]

    TCHAR* data()
    { return (TCHAR*)(this + 1); }
};

// Globals

// For an empty string, m_pchData will point here
// (note: avoids special case of checking for NULL m_pchData)
// empty string data (and locked)
_declspec(selectany) int rgInitData[] = { -1, 0, 0, 0 };
_declspec(selectany) CStringData* _atltmpDataNil = (CStringData*)&rgInitData;
_declspec(selectany) LPCTSTR _atltmpPchNil = (LPCTSTR)(((BYTE*)&rgInitData) + sizeof(CStringData));


class CString
{
public:
// Constructors
    CString()
    {
        Init();
    }

    CString(const CString& stringSrc)
    {
        ATLASSERT(stringSrc.GetData()->nRefs != 0);
        if (stringSrc.GetData()->nRefs >= 0)
        {
            ATLASSERT(stringSrc.GetData() != _atltmpDataNil);
            m_pchData = stringSrc.m_pchData;
            InterlockedIncrement(&GetData()->nRefs);
        }
        else
        {
            Init();
            *this = stringSrc.m_pchData;
        }
    }

    CString(TCHAR ch, int nRepeat = 1)
    {
        ATLASSERT(!_istlead(ch));   // can't create a lead byte string
        Init();
        if (nRepeat >= 1)
        {
            if(AllocBuffer(nRepeat))
            {
#ifdef _UNICODE
                for (int i = 0; i < nRepeat; i++)
                    m_pchData[i] = ch;
#else
                memset(m_pchData, ch, nRepeat);
#endif
            }
        }
    }

    CString(LPCTSTR lpsz)
    {
        Init();
        if (lpsz != NULL && HIWORD(lpsz) == NULL)
        {
            UINT nID = LOWORD((DWORD_PTR)lpsz);
            if (!LoadString(nID))
                ATLTRACE2(atlTraceUI, 0, _T("Warning: implicit LoadString(%u) in CString failed\n"), nID);
        }
        else
        {
            int nLen = SafeStrlen(lpsz);
            if (nLen != 0)
            {
                if(AllocBuffer(nLen))
                    SecureHelper::memcpy_x(m_pchData, (nLen + 1) * sizeof(TCHAR), lpsz, nLen * sizeof(TCHAR));
            }
        }
    }

#ifdef _UNICODE
    CString(LPCSTR lpsz)
    {
        Init();
#if defined(_WIN32_WCE) && (_ATL_VER >= 0x0800)
        int nSrcLen = (lpsz != NULL) ? ATL::lstrlenA(lpsz) : 0;
#else
        int nSrcLen = (lpsz != NULL) ? lstrlenA(lpsz) : 0;
#endif
        if (nSrcLen != 0)
        {
            if(AllocBuffer(nSrcLen))
            {
                _mbstowcsz(m_pchData, lpsz, nSrcLen + 1);
                ReleaseBuffer();
            }
        }
    }
#else // !_UNICODE
    CString(LPCWSTR lpsz)
    {
        Init();
        int nSrcLen = (lpsz != NULL) ? (int)wcslen(lpsz) : 0;
        if (nSrcLen != 0)
        {
            if(AllocBuffer(nSrcLen * 2))
            {
                _wcstombsz(m_pchData, lpsz, (nSrcLen * 2) + 1);
                ReleaseBuffer();
            }
        }
    }
#endif // !_UNICODE

    CString(LPCTSTR lpch, int nLength)
    {
        Init();
        if (nLength != 0)
        {
            if(AllocBuffer(nLength))
                SecureHelper::memcpy_x(m_pchData, (nLength + 1) * sizeof(TCHAR), lpch, nLength * sizeof(TCHAR));
        }
    }

#ifdef _UNICODE
    CString(LPCSTR lpsz, int nLength)
    {
        Init();
        if (nLength != 0)
        {
            if(AllocBuffer(nLength))
            {
                int n = ::MultiByteToWideChar(CP_ACP, 0, lpsz, nLength, m_pchData, nLength + 1);
                ReleaseBuffer((n >= 0) ? n : -1);
            }
        }
    }
#else // !_UNICODE
    CString(LPCWSTR lpsz, int nLength)
    {
        Init();
        if (nLength != 0)
        {
            if(((nLength * 2) > nLength) && AllocBuffer(nLength * 2))
            {
                int n = ::WideCharToMultiByte(CP_ACP, 0, lpsz, nLength, m_pchData, (nLength * 2) + 1, NULL, NULL);
                ReleaseBuffer((n >= 0) ? n : -1);
            }
        }
    }
#endif // !_UNICODE

    CString(const unsigned char* lpsz)
    {
        Init();
        *this = (LPCSTR)lpsz;
    }

// Attributes & Operations
    int GetLength() const   // as an array of characters
    {
        return GetData()->nDataLength;
    }

    BOOL IsEmpty() const
    {
        return GetData()->nDataLength == 0;
    }

    void Empty()   // free up the data
    {
        if (GetData()->nDataLength == 0)
            return;

        if (GetData()->nRefs >= 0)
            Release();
        else
            *this = _T("");

        ATLASSERT(GetData()->nDataLength == 0);
        ATLASSERT(GetData()->nRefs < 0 || GetData()->nAllocLength == 0);
    }

    TCHAR GetAt(int nIndex) const   // 0 based
    {
        ATLASSERT(nIndex >= 0);
        ATLASSERT(nIndex < GetData()->nDataLength);
        return m_pchData[nIndex];
    }

    TCHAR operator [](int nIndex) const   // same as GetAt
    {
        // same as GetAt
        ATLASSERT(nIndex >= 0);
        ATLASSERT(nIndex < GetData()->nDataLength);
        return m_pchData[nIndex];
    }

    void SetAt(int nIndex, TCHAR ch)
    {
        ATLASSERT(nIndex >= 0);
        ATLASSERT(nIndex < GetData()->nDataLength);

        CopyBeforeWrite();
        m_pchData[nIndex] = ch;
    }

    operator LPCTSTR() const   // as a C string
    {
        return m_pchData;
    }

    // overloaded assignment
    CString& operator =(const CString& stringSrc)
    {
        if (m_pchData != stringSrc.m_pchData)
        {
            if ((GetData()->nRefs < 0 && GetData() != _atltmpDataNil) || stringSrc.GetData()->nRefs < 0)
            {
                // actual copy necessary since one of the strings is locked
                AssignCopy(stringSrc.GetData()->nDataLength, stringSrc.m_pchData);
            }
            else
            {
                // can just copy references around
                Release();
                ATLASSERT(stringSrc.GetData() != _atltmpDataNil);
                m_pchData = stringSrc.m_pchData;
                InterlockedIncrement(&GetData()->nRefs);
            }
        }
        return *this;
    }

    CString& operator =(TCHAR ch)
    {
        ATLASSERT(!_istlead(ch));   // can't set single lead byte
        AssignCopy(1, &ch);
        return *this;
    }

#ifdef _UNICODE
    CString& operator =(char ch)
    {
        *this = (TCHAR)ch;
        return *this;
    }
#endif

    CString& operator =(LPCTSTR lpsz)
    {
        ATLASSERT(lpsz == NULL || _IsValidString(lpsz));
        AssignCopy(SafeStrlen(lpsz), lpsz);
        return *this;
    }

#ifdef _UNICODE
    CString& operator =(LPCSTR lpsz)
    {
#if defined(_WIN32_WCE) && (_ATL_VER >= 0x0800)
        int nSrcLen = (lpsz != NULL) ? ATL::lstrlenA(lpsz) : 0;
#else
        int nSrcLen = (lpsz != NULL) ? lstrlenA(lpsz) : 0;
#endif
        if(AllocBeforeWrite(nSrcLen))
        {
            _mbstowcsz(m_pchData, lpsz, nSrcLen + 1);
            ReleaseBuffer();
        }
        return *this;
    }
#else // !_UNICODE
    CString& operator =(LPCWSTR lpsz)
    {
        int nSrcLen = (lpsz != NULL) ? (int)wcslen(lpsz) : 0;
        if(AllocBeforeWrite(nSrcLen * 2))
        {
            _wcstombsz(m_pchData, lpsz, (nSrcLen * 2) + 1);
            ReleaseBuffer();
        }
        return *this;
    }
#endif  // !_UNICODE

    CString& operator =(const unsigned char* lpsz)
    {
        *this = (LPCSTR)lpsz;
        return *this;
    }

    // string concatenation
    CString& operator +=(const CString& string)
    {
        ConcatInPlace(string.GetData()->nDataLength, string.m_pchData);
        return *this;
    }

    CString& operator +=(TCHAR ch)
    {
        ConcatInPlace(1, &ch);
        return *this;
    }

#ifdef _UNICODE
    CString& operator +=(char ch)
    {
        *this += (TCHAR)ch;
        return *this;
    }
#endif

    CString& operator +=(LPCTSTR lpsz)
    {
        ATLASSERT(lpsz == NULL || _IsValidString(lpsz));
        ConcatInPlace(SafeStrlen(lpsz), lpsz);
        return *this;
    }

    friend CString __stdcall operator +(const CString& string1, const CString& string2);
    friend CString __stdcall operator +(const CString& string, TCHAR ch);
    friend CString __stdcall operator +(TCHAR ch, const CString& string);
#ifdef _UNICODE
    friend CString __stdcall operator +(const CString& string, char ch);
    friend CString __stdcall operator +(char ch, const CString& string);
#endif
    friend CString __stdcall operator +(const CString& string, LPCTSTR lpsz);
    friend CString __stdcall operator +(LPCTSTR lpsz, const CString& string);

    // string comparison
    int Compare(LPCTSTR lpsz) const   // straight character (MBCS/Unicode aware)
    {
        return _cstrcmp(m_pchData, lpsz);
    }

    int CompareNoCase(LPCTSTR lpsz) const   // ignore case (MBCS/Unicode aware)
    {
        return _cstrcmpi(m_pchData, lpsz);
    }

#ifndef _WIN32_WCE
    // CString::Collate is often slower than Compare but is MBSC/Unicode
    //  aware as well as locale-sensitive with respect to sort order.
    int Collate(LPCTSTR lpsz) const   // NLS aware
    {
        return _cstrcoll(m_pchData, lpsz);
    }

    int CollateNoCase(LPCTSTR lpsz) const   // ignore case
    {
        return _cstrcolli(m_pchData, lpsz);
    }
#endif // !_WIN32_WCE

    // simple sub-string extraction
    CString Mid(int nFirst, int nCount) const
    {
        // out-of-bounds requests return sensible things
        if (nFirst < 0)
            nFirst = 0;
        if (nCount < 0)
            nCount = 0;

        if (nFirst + nCount > GetData()->nDataLength)
            nCount = GetData()->nDataLength - nFirst;
        if (nFirst > GetData()->nDataLength)
            nCount = 0;

        CString dest;
        AllocCopy(dest, nCount, nFirst, 0);
        return dest;
    }

    CString Mid(int nFirst) const
    {
        return Mid(nFirst, GetData()->nDataLength - nFirst);
    }

    CString Left(int nCount) const
    {
        if (nCount < 0)
            nCount = 0;
        else if (nCount > GetData()->nDataLength)
            nCount = GetData()->nDataLength;

        CString dest;
        AllocCopy(dest, nCount, 0, 0);
        return dest;
    }

    CString Right(int nCount) const
    {
        if (nCount < 0)
            nCount = 0;
        else if (nCount > GetData()->nDataLength)
            nCount = GetData()->nDataLength;

        CString dest;
        AllocCopy(dest, nCount, GetData()->nDataLength-nCount, 0);
        return dest;
    }

    CString SpanIncluding(LPCTSTR lpszCharSet) const   // strspn equivalent
    {
        ATLASSERT(_IsValidString(lpszCharSet));
        return Left(_cstrspn(m_pchData, lpszCharSet));
    }

    CString SpanExcluding(LPCTSTR lpszCharSet) const   // strcspn equivalent
    {
        ATLASSERT(_IsValidString(lpszCharSet));
        return Left(_cstrcspn(m_pchData, lpszCharSet));
    }

    // upper/lower/reverse conversion
    void MakeUpper()
    {
        CopyBeforeWrite();
        CharUpper(m_pchData);
    }

    void MakeLower()
    {
        CopyBeforeWrite();
        CharLower(m_pchData);
    }

    void MakeReverse()
    {
        CopyBeforeWrite();
        _cstrrev(m_pchData);
    }

    // trimming whitespace (either side)
    void TrimRight()
    {
        CopyBeforeWrite();

        // find beginning of trailing spaces by starting at beginning (DBCS aware)
        LPTSTR lpsz = m_pchData;
        LPTSTR lpszLast = NULL;
        while (*lpsz != _T('\0'))
        {
            if (_cstrisspace(*lpsz))
            {
                if (lpszLast == NULL)
                    lpszLast = lpsz;
            }
            else
            {
                lpszLast = NULL;
            }
            lpsz = ::CharNext(lpsz);
        }

        if (lpszLast != NULL)
        {
            // truncate at trailing space start
            *lpszLast = _T('\0');
            GetData()->nDataLength = (int)(DWORD_PTR)(lpszLast - m_pchData);
        }
    }

    void TrimLeft()
    {
        CopyBeforeWrite();

        // find first non-space character
        LPCTSTR lpsz = m_pchData;
        while (_cstrisspace(*lpsz))
            lpsz = ::CharNext(lpsz);

        // fix up data and length
        int nDataLength = GetData()->nDataLength - (int)(DWORD_PTR)(lpsz - m_pchData);
        SecureHelper::memmove_x(m_pchData, (GetData()->nAllocLength + 1) * sizeof(TCHAR), lpsz, (nDataLength + 1) * sizeof(TCHAR));
        GetData()->nDataLength = nDataLength;
    }

    // remove continuous occurrences of chTarget starting from right
    void TrimRight(TCHAR chTarget)
    {
        // find beginning of trailing matches
        // by starting at beginning (DBCS aware)

        CopyBeforeWrite();
        LPTSTR lpsz = m_pchData;
        LPTSTR lpszLast = NULL;

        while (*lpsz != _T('\0'))
        {
            if (*lpsz == chTarget)
            {
                if (lpszLast == NULL)
                    lpszLast = lpsz;
            }
            else
                lpszLast = NULL;
            lpsz = ::CharNext(lpsz);
        }

        if (lpszLast != NULL)
        {
            // truncate at left-most matching character
            *lpszLast = _T('\0');
            GetData()->nDataLength = (int)(DWORD_PTR)(lpszLast - m_pchData);
        }
    }

    // remove continuous occcurrences of characters in passed string, starting from right
    void TrimRight(LPCTSTR lpszTargetList)
    {
        // find beginning of trailing matches by starting at beginning (DBCS aware)

        CopyBeforeWrite();
        LPTSTR lpsz = m_pchData;
        LPTSTR lpszLast = NULL;

        while (*lpsz != _T('\0'))
        {
            TCHAR* pNext = ::CharNext(lpsz);
            if(pNext > lpsz + 1)
            {
                if (_cstrchr_db(lpszTargetList, *lpsz, *(lpsz + 1)) != NULL)
                {
                    if (lpszLast == NULL)
                        lpszLast = lpsz;
                }
                else
                {
                    lpszLast = NULL;
                }
            }
            else
            {
                if (_cstrchr(lpszTargetList, *lpsz) != NULL)
                {
                    if (lpszLast == NULL)
                        lpszLast = lpsz;
                }
                else
                {
                    lpszLast = NULL;
                }
            }

            lpsz = pNext;
        }

        if (lpszLast != NULL)
        {
            // truncate at left-most matching character
            *lpszLast = _T('\0');
            GetData()->nDataLength = (int)(DWORD_PTR)(lpszLast - m_pchData);
        }
    }

    // remove continuous occurrences of chTarget starting from left
    void TrimLeft(TCHAR chTarget)
    {
        // find first non-matching character

        CopyBeforeWrite();
        LPCTSTR lpsz = m_pchData;

        while (chTarget == *lpsz)
            lpsz = ::CharNext(lpsz);

        if (lpsz != m_pchData)
        {
            // fix up data and length
            int nDataLength = GetData()->nDataLength - (int)(DWORD_PTR)(lpsz - m_pchData);
            SecureHelper::memmove_x(m_pchData, (GetData()->nAllocLength + 1) * sizeof(TCHAR), lpsz, (nDataLength + 1) * sizeof(TCHAR));
            GetData()->nDataLength = nDataLength;
        }
    }

    // remove continuous occcurrences of characters in passed string, starting from left
    void TrimLeft(LPCTSTR lpszTargets)
    {
        // if we're not trimming anything, we're not doing any work
        if (SafeStrlen(lpszTargets) == 0)
            return;

        CopyBeforeWrite();
        LPCTSTR lpsz = m_pchData;

        while (*lpsz != _T('\0'))
        {
            TCHAR* pNext = ::CharNext(lpsz);
            if(pNext > lpsz + 1)
            {
                if (_cstrchr_db(lpszTargets, *lpsz, *(lpsz + 1)) == NULL)
                    break;
            }
            else
            {
                if (_cstrchr(lpszTargets, *lpsz) == NULL)
                    break;
            }
            lpsz = pNext;
        }

        if (lpsz != m_pchData)
        {
            // fix up data and length
            int nDataLength = GetData()->nDataLength - (int)(DWORD_PTR)(lpsz - m_pchData);
            SecureHelper::memmove_x(m_pchData, (GetData()->nAllocLength + 1) * sizeof(TCHAR), lpsz, (nDataLength + 1) * sizeof(TCHAR));
            GetData()->nDataLength = nDataLength;
        }
    }

    // advanced manipulation
    // replace occurrences of chOld with chNew
    int Replace(TCHAR chOld, TCHAR chNew)
    {
        int nCount = 0;

        // short-circuit the nop case
        if (chOld != chNew)
        {
            // otherwise modify each character that matches in the string
            CopyBeforeWrite();
            LPTSTR psz = m_pchData;
            LPTSTR pszEnd = psz + GetData()->nDataLength;
            while (psz < pszEnd)
            {
                // replace instances of the specified character only
                if (*psz == chOld)
                {
                    *psz = chNew;
                    nCount++;
                }
                psz = ::CharNext(psz);
            }
        }
        return nCount;
    }

    // replace occurrences of substring lpszOld with lpszNew;
    // empty lpszNew removes instances of lpszOld
    int Replace(LPCTSTR lpszOld, LPCTSTR lpszNew)
    {
        // can't have empty or NULL lpszOld

        int nSourceLen = SafeStrlen(lpszOld);
        if (nSourceLen == 0)
            return 0;
        int nReplacementLen = SafeStrlen(lpszNew);

        // loop once to figure out the size of the result string
        int nCount = 0;
        LPTSTR lpszStart = m_pchData;
        LPTSTR lpszEnd = m_pchData + GetData()->nDataLength;
        LPTSTR lpszTarget = NULL;
        while (lpszStart < lpszEnd)
        {
            while ((lpszTarget = (TCHAR*)_cstrstr(lpszStart, lpszOld)) != NULL)
            {
                nCount++;
                lpszStart = lpszTarget + nSourceLen;
            }
            lpszStart += lstrlen(lpszStart) + 1;
        }

        // if any changes were made, make them
        if (nCount > 0)
        {
            CopyBeforeWrite();

            // if the buffer is too small, just allocate a new buffer (slow but sure)
            int nOldLength = GetData()->nDataLength;
            int nNewLength =  nOldLength + (nReplacementLen - nSourceLen) * nCount;
            if (GetData()->nAllocLength < nNewLength || GetData()->nRefs > 1)
            {
                CStringData* pOldData = GetData();
                LPTSTR pstr = m_pchData;
                if(!AllocBuffer(nNewLength))
                    return -1;
                SecureHelper::memcpy_x(m_pchData, (nNewLength + 1) * sizeof(TCHAR), pstr, pOldData->nDataLength * sizeof(TCHAR));
                CString::Release(pOldData);
            }
            // else, we just do it in-place
            lpszStart = m_pchData;
            lpszEnd = m_pchData + GetData()->nDataLength;

            // loop again to actually do the work
            while (lpszStart < lpszEnd)
            {
                while ((lpszTarget = (TCHAR*)_cstrstr(lpszStart, lpszOld)) != NULL)
                {
                    int nBalance = nOldLength - ((int)(DWORD_PTR)(lpszTarget - m_pchData) + nSourceLen);
                    int cchBuffLen = GetData()->nAllocLength - (int)(DWORD_PTR)(lpszTarget - m_pchData);
                    SecureHelper::memmove_x(lpszTarget + nReplacementLen, (cchBuffLen - nReplacementLen + 1) * sizeof(TCHAR), lpszTarget + nSourceLen, nBalance * sizeof(TCHAR));
                    SecureHelper::memcpy_x(lpszTarget, (cchBuffLen + 1) * sizeof(TCHAR), lpszNew, nReplacementLen * sizeof(TCHAR));
                    lpszStart = lpszTarget + nReplacementLen;
                    lpszStart[nBalance] = _T('\0');
                    nOldLength += (nReplacementLen - nSourceLen);
                }
                lpszStart += lstrlen(lpszStart) + 1;
            }
            ATLASSERT(m_pchData[nNewLength] == _T('\0'));
            GetData()->nDataLength = nNewLength;
        }

        return nCount;
    }

    // remove occurrences of chRemove
    int Remove(TCHAR chRemove)
    {
        CopyBeforeWrite();

        LPTSTR pstrSource = m_pchData;
        LPTSTR pstrDest = m_pchData;
        LPTSTR pstrEnd = m_pchData + GetData()->nDataLength;

        while (pstrSource < pstrEnd)
        {
            if (*pstrSource != chRemove)
            {
                *pstrDest = *pstrSource;
                pstrDest = ::CharNext(pstrDest);
            }
            pstrSource = ::CharNext(pstrSource);
        }
        *pstrDest = _T('\0');
        int nCount = (int)(DWORD_PTR)(pstrSource - pstrDest);
        GetData()->nDataLength -= nCount;

        return nCount;
    }

    // insert character at zero-based index; concatenates if index is past end of string
    int Insert(int nIndex, TCHAR ch)
    {
        CopyBeforeWrite();

        if (nIndex < 0)
            nIndex = 0;

        int nNewLength = GetData()->nDataLength;
        if (nIndex > nNewLength)
            nIndex = nNewLength;
        nNewLength++;

        if (GetData()->nAllocLength < nNewLength)
        {
            CStringData* pOldData = GetData();
            LPTSTR pstr = m_pchData;
            if(!AllocBuffer(nNewLength))
                return -1;
            SecureHelper::memcpy_x(m_pchData, (nNewLength + 1) * sizeof(TCHAR), pstr, (pOldData->nDataLength + 1) * sizeof(TCHAR));
            CString::Release(pOldData);
        }

        // move existing bytes down
        SecureHelper::memmove_x(m_pchData + nIndex + 1, (GetData()->nAllocLength - nIndex) * sizeof(TCHAR), m_pchData + nIndex, (nNewLength - nIndex) * sizeof(TCHAR));
        m_pchData[nIndex] = ch;
        GetData()->nDataLength = nNewLength;

        return nNewLength;
    }

    // insert substring at zero-based index; concatenates if index is past end of string
    int Insert(int nIndex, LPCTSTR pstr)
    {
        if (nIndex < 0)
            nIndex = 0;

        int nInsertLength = SafeStrlen(pstr);
        int nNewLength = GetData()->nDataLength;
        if (nInsertLength > 0)
        {
            CopyBeforeWrite();
            if (nIndex > nNewLength)
                nIndex = nNewLength;
            nNewLength += nInsertLength;

            if (GetData()->nAllocLength < nNewLength)
            {
                CStringData* pOldData = GetData();
                LPTSTR pstrTmp = m_pchData;
                if(!AllocBuffer(nNewLength))
                    return -1;
                SecureHelper::memcpy_x(m_pchData, (nNewLength + 1) * sizeof(TCHAR), pstrTmp, (pOldData->nDataLength + 1) * sizeof(TCHAR));
                CString::Release(pOldData);
            }

            // move existing bytes down
            SecureHelper::memmove_x(m_pchData + nIndex + nInsertLength, (GetData()->nAllocLength + 1 - nIndex - nInsertLength) * sizeof(TCHAR), m_pchData + nIndex, (nNewLength - nIndex - nInsertLength + 1) * sizeof(TCHAR));
            SecureHelper::memcpy_x(m_pchData + nIndex, (GetData()->nAllocLength + 1 - nIndex) * sizeof(TCHAR), pstr, nInsertLength * sizeof(TCHAR));
            GetData()->nDataLength = nNewLength;
        }

        return nNewLength;
    }

    // delete nCount characters starting at zero-based index
    int Delete(int nIndex, int nCount = 1)
    {
        if (nIndex < 0)
            nIndex = 0;
        int nLength = GetData()->nDataLength;
        if (nCount > 0 && nIndex < nLength)
        {
            if((nIndex + nCount) > nLength)
                nCount = nLength - nIndex;
            CopyBeforeWrite();
            int nBytesToCopy = nLength - (nIndex + nCount) + 1;

            SecureHelper::memmove_x(m_pchData + nIndex, (GetData()->nAllocLength + 1 - nIndex) * sizeof(TCHAR), m_pchData + nIndex + nCount, nBytesToCopy * sizeof(TCHAR));
            nLength -= nCount;
            GetData()->nDataLength = nLength;
        }

        return nLength;
    }

    // searching (return starting index, or -1 if not found)
    // look for a single character match
    int Find(TCHAR ch) const   // like "C" strchr
    {
        return Find(ch, 0);
    }

    int ReverseFind(TCHAR ch) const
    {
        // find last single character
        LPCTSTR lpsz = _cstrrchr(m_pchData, (_TUCHAR)ch);

        // return -1 if not found, distance from beginning otherwise
        return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
    }

    int Find(TCHAR ch, int nStart) const   // starting at index
    {
        int nLength = GetData()->nDataLength;
        if (nStart < 0 || nStart >= nLength)
            return -1;

        // find first single character
        LPCTSTR lpsz = _cstrchr(m_pchData + nStart, (_TUCHAR)ch);

        // return -1 if not found and index otherwise
        return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
    }

    int FindOneOf(LPCTSTR lpszCharSet) const
    {
        ATLASSERT(_IsValidString(lpszCharSet));
        LPCTSTR lpsz = _cstrpbrk(m_pchData, lpszCharSet);
        return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
    }

    // look for a specific sub-string
    // find a sub-string (like strstr)
    int Find(LPCTSTR lpszSub) const   // like "C" strstr
    {
        return Find(lpszSub, 0);
    }

    int Find(LPCTSTR lpszSub, int nStart) const   // starting at index
    {
        ATLASSERT(_IsValidString(lpszSub));

        int nLength = GetData()->nDataLength;
        if (nStart < 0 || nStart > nLength)
            return -1;

        // find first matching substring
        LPCTSTR lpsz = _cstrstr(m_pchData + nStart, lpszSub);

        // return -1 for not found, distance from beginning otherwise
        return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
    }

    // Concatentation for non strings
    CString& Append(int n)
    {
        const int cchBuff = 12;
        TCHAR szBuffer[cchBuff] = { 0 };
        SecureHelper::wsprintf_x(szBuffer, cchBuff, _T("%d"), n);
        ConcatInPlace(SafeStrlen(szBuffer), szBuffer);
        return *this;
    }

    // simple formatting
    // formatting (using wsprintf style formatting)
    BOOL __cdecl Format(LPCTSTR lpszFormat, ...)
    {
        ATLASSERT(_IsValidString(lpszFormat));

        va_list argList;
        va_start(argList, lpszFormat);
        BOOL bRet = FormatV(lpszFormat, argList);
        va_end(argList);
        return bRet;
    }

    BOOL __cdecl Format(UINT nFormatID, ...)
    {
        CString strFormat;
        BOOL bRet = strFormat.LoadString(nFormatID);
        ATLASSERT(bRet != 0);

        va_list argList;
        va_start(argList, nFormatID);
        bRet = FormatV(strFormat, argList);
        va_end(argList);
        return bRet;
    }

    BOOL FormatV(LPCTSTR lpszFormat, va_list argList)
    {
        ATLASSERT(_IsValidString(lpszFormat));

        enum _FormatModifiers
        {
            FORCE_ANSI =    0x10000,
            FORCE_UNICODE = 0x20000,
            FORCE_INT64 =   0x40000
        };

        va_list argListSave = argList;

        // make a guess at the maximum length of the resulting string
        int nMaxLen = 0;
        for (LPCTSTR lpsz = lpszFormat; *lpsz != _T('\0'); lpsz = ::CharNext(lpsz))
        {
            // handle '%' character, but watch out for '%%'
            if (*lpsz != _T('%') || *(lpsz = ::CharNext(lpsz)) == _T('%'))
            {
                nMaxLen += (int)(::CharNext(lpsz) - lpsz);
                continue;
            }

            int nItemLen = 0;

            // handle '%' character with format
            int nWidth = 0;
            for (; *lpsz != _T('\0'); lpsz = ::CharNext(lpsz))
            {
                // check for valid flags
                if (*lpsz == _T('#'))
                    nMaxLen += 2;   // for '0x'
                else if (*lpsz == _T('*'))
                    nWidth = va_arg(argList, int);
                else if (*lpsz == _T('-') || *lpsz == _T('+') || *lpsz == _T('0') || *lpsz == _T(' '))
                    ;
                else // hit non-flag character
                    break;
            }
            // get width and skip it
            if (nWidth == 0)
            {
                // width indicated by
                nWidth = _cstrtoi(lpsz);
                for (; *lpsz != _T('\0') && _cstrisdigit(*lpsz); lpsz = ::CharNext(lpsz))
                    ;
            }
            ATLASSERT(nWidth >= 0);

            int nPrecision = 0;
            if (*lpsz == _T('.'))
            {
                // skip past '.' separator (width.precision)
                lpsz = ::CharNext(lpsz);

                // get precision and skip it
                if (*lpsz == _T('*'))
                {
                    nPrecision = va_arg(argList, int);
                    lpsz = ::CharNext(lpsz);
                }
                else
                {
                    nPrecision = _cstrtoi(lpsz);
                    for (; *lpsz != _T('\0') && _cstrisdigit(*lpsz); lpsz = ::CharNext(lpsz))
                        ;
                }
                ATLASSERT(nPrecision >= 0);
            }

            // should be on type modifier or specifier
            int nModifier = 0;
            if(lpsz[0] == _T('I'))
            {
                if((lpsz[1] == _T('6')) && (lpsz[2] == _T('4')))
                {
                    lpsz += 3;
                    nModifier = FORCE_INT64;
                }
                else if((lpsz[1] == _T('3')) && (lpsz[2] == _T('2')))
                {
                    lpsz += 3;
                }
                else
                {
                    lpsz++;
                    if(sizeof(size_t) == 8)
                        nModifier = FORCE_INT64;
                }
            }
            else
            {
                switch (*lpsz)
                {
                // modifiers that affect size
                case _T('h'):
                    nModifier = FORCE_ANSI;
                    lpsz = ::CharNext(lpsz);
                    break;
                case _T('l'):
                    nModifier = FORCE_UNICODE;
                    lpsz = ::CharNext(lpsz);
                    break;

                // modifiers that do not affect size
                case _T('F'):
                case _T('N'):
                case _T('L'):
                    lpsz = ::CharNext(lpsz);
                    break;
                }
            }

            // now should be on specifier
            switch (*lpsz | nModifier)
            {
            // single characters
            case _T('c'):
            case _T('C'):
                nItemLen = 2;
                va_arg(argList, TCHAR);
                break;
            case _T('c') | FORCE_ANSI:
            case _T('C') | FORCE_ANSI:
                nItemLen = 2;
                va_arg(argList, char);
                break;
            case _T('c') | FORCE_UNICODE:
            case _T('C') | FORCE_UNICODE:
                nItemLen = 2;
                va_arg(argList, WCHAR);
                break;

            // strings
            case _T('s'):
            {
                LPCTSTR pstrNextArg = va_arg(argList, LPCTSTR);
                if (pstrNextArg == NULL)
                {
                    nItemLen = 6;  // "(null)"
                }
                else
                {
                    nItemLen = lstrlen(pstrNextArg);
                    nItemLen = __max(1, nItemLen);
                }
                break;
            }

            case _T('S'):
            {
#ifndef _UNICODE
                LPWSTR pstrNextArg = va_arg(argList, LPWSTR);
                if (pstrNextArg == NULL)
                {
                    nItemLen = 6;  // "(null)"
                }
                else
                {
                    nItemLen = (int)wcslen(pstrNextArg);
                    nItemLen = __max(1, nItemLen);
                }
#else // _UNICODE
                LPCSTR pstrNextArg = va_arg(argList, LPCSTR);
                if (pstrNextArg == NULL)
                {
                    nItemLen = 6; // "(null)"
                }
                else
                {
#if defined(_WIN32_WCE) && (_ATL_VER >= 0x0800)
                    nItemLen = ATL::lstrlenA(pstrNextArg);
#else
                    nItemLen = lstrlenA(pstrNextArg);
#endif
                    nItemLen = __max(1, nItemLen);
                }
#endif // _UNICODE
                break;
            }

            case _T('s') | FORCE_ANSI:
            case _T('S') | FORCE_ANSI:
            {
                LPCSTR pstrNextArg = va_arg(argList, LPCSTR);
                if (pstrNextArg == NULL)
                {
                    nItemLen = 6; // "(null)"
                }
                else
                {
#if defined(_WIN32_WCE) && (_ATL_VER >= 0x0800)
                    nItemLen = ATL::lstrlenA(pstrNextArg);
#else
                    nItemLen = lstrlenA(pstrNextArg);
#endif
                    nItemLen = __max(1, nItemLen);
                }
                break;
            }

            case _T('s') | FORCE_UNICODE:
            case _T('S') | FORCE_UNICODE:
            {
                LPWSTR pstrNextArg = va_arg(argList, LPWSTR);
                if (pstrNextArg == NULL)
                {
                    nItemLen = 6; // "(null)"
                }
                else
                {
                    nItemLen = (int)wcslen(pstrNextArg);
                    nItemLen = __max(1, nItemLen);
                }
                break;
            }
            }

            // adjust nItemLen for strings
            if (nItemLen != 0)
            {
                nItemLen = __max(nItemLen, nWidth);
                if (nPrecision != 0)
                    nItemLen = __min(nItemLen, nPrecision);
            }
            else
            {
                switch (*lpsz)
                {
                // integers
                case _T('d'):
                case _T('i'):
                case _T('u'):
                case _T('x'):
                case _T('X'):
                case _T('o'):
                    if (nModifier & FORCE_INT64)
                        va_arg(argList, __int64);
                    else
                        va_arg(argList, int);
                    nItemLen = 32;
                    nItemLen = __max(nItemLen, nWidth + nPrecision);
                    break;

#ifndef _ATL_USE_CSTRING_FLOAT
                case _T('e'):
                case _T('E'):
                case _T('f'):
                case _T('g'):
                case _T('G'):
                    ATLASSERT(!"Floating point (%%e, %%E, %%f, %%g, and %%G) is not supported by the WTL::CString class.");
#ifndef _DEBUG
                    ::OutputDebugString(_T("Floating point (%%e, %%f, %%g, and %%G) is not supported by the WTL::CString class."));
#ifndef _WIN32_WCE
                    ::DebugBreak();
#else // CE specific
                    DebugBreak();
#endif // _WIN32_WCE
#endif // !_DEBUG
                    break;
#else // _ATL_USE_CSTRING_FLOAT
                case _T('e'):
                case _T('E'):
                case _T('g'):
                case _T('G'):
                    va_arg(argList, double);
                    nItemLen = 128;
                    nItemLen = __max(nItemLen, nWidth + nPrecision);
                    break;
                case _T('f'):
                    {
                        double f = va_arg(argList, double);
                        // 312 == strlen("-1+(309 zeroes).")
                        // 309 zeroes == max precision of a double
                        // 6 == adjustment in case precision is not specified,
                        //   which means that the precision defaults to 6
                        int cchLen = __max(nWidth, 312 + nPrecision + 6);
                        CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
                        LPTSTR pszTemp = buff.Allocate(cchLen);
                        if(pszTemp != NULL)
                        {
                            SecureHelper::sprintf_x(pszTemp, cchLen, _T("%*.*f"), nWidth, nPrecision + 6, f);
                            nItemLen = (int)_tcslen(pszTemp);
                        }
                        else
                        {
                            nItemLen = cchLen;
                        }
                    }
                    break;
#endif // _ATL_USE_CSTRING_FLOAT

                case _T('p'):
                    va_arg(argList, void*);
                    nItemLen = 32;
                    nItemLen = __max(nItemLen, nWidth + nPrecision);
                    break;

                // no output
                case _T('n'):
                    va_arg(argList, int*);
                    break;

                default:
                    ATLASSERT(FALSE);  // unknown formatting option
                }
            }

            // adjust nMaxLen for output nItemLen
            nMaxLen += nItemLen;
        }

        if(GetBuffer(nMaxLen) == NULL)
            return FALSE;
#ifndef _ATL_USE_CSTRING_FLOAT
        int nRet = SecureHelper::wvsprintf_x(m_pchData, GetAllocLength() + 1, lpszFormat, argListSave);
#else // _ATL_USE_CSTRING_FLOAT
        int nRet = SecureHelper::vsprintf_x(m_pchData, GetAllocLength() + 1, lpszFormat, argListSave);
#endif // _ATL_USE_CSTRING_FLOAT
        nRet;   // ref
        ATLASSERT(nRet <= GetAllocLength());
        ReleaseBuffer();

        va_end(argListSave);
        return TRUE;
    }

    // formatting for localization (uses FormatMessage API)
    // formatting (using FormatMessage style formatting)
    BOOL __cdecl FormatMessage(LPCTSTR lpszFormat, ...)
    {
        // format message into temporary buffer lpszTemp
        va_list argList;
        va_start(argList, lpszFormat);
        LPTSTR lpszTemp = NULL;
        BOOL bRet = TRUE;

        if ((::FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                lpszFormat, 0, 0, (LPTSTR)&lpszTemp, 0, &argList) == 0) || (lpszTemp == NULL))
            bRet = FALSE;

        // assign lpszTemp into the resulting string and free the temporary
        *this = lpszTemp;
        LocalFree(lpszTemp);
        va_end(argList);
        return bRet;
    }

    BOOL __cdecl FormatMessage(UINT nFormatID, ...)
    {
        // get format string from string table
        CString strFormat;
        BOOL bRetTmp = strFormat.LoadString(nFormatID);
        bRetTmp;   // ref
        ATLASSERT(bRetTmp != 0);

        // format message into temporary buffer lpszTemp
        va_list argList;
        va_start(argList, nFormatID);
        LPTSTR lpszTemp = NULL;
        BOOL bRet = TRUE;

        if ((::FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                strFormat, 0, 0, (LPTSTR)&lpszTemp, 0, &argList) == 0) || (lpszTemp == NULL))
            bRet = FALSE;

        // assign lpszTemp into the resulting string and free lpszTemp
        *this = lpszTemp;
        LocalFree(lpszTemp);
        va_end(argList);
        return bRet;
    }

    // Windows support
    BOOL LoadString(UINT nID)   // load from string resource (255 chars max.)
    {
#ifdef _UNICODE
        const int CHAR_FUDGE = 1;   // one TCHAR unused is good enough
#else
        const int CHAR_FUDGE = 2;   // two BYTES unused for case of DBC last char
#endif

        // try fixed buffer first (to avoid wasting space in the heap)
        TCHAR szTemp[256] = { 0 };
        int nCount =  sizeof(szTemp) / sizeof(szTemp[0]);
        int nLen = _LoadString(nID, szTemp, nCount);
        if (nCount - nLen > CHAR_FUDGE)
        {
            *this = szTemp;
            return (nLen > 0);
        }

        // try buffer size of 512, then larger size until entire string is retrieved
        int nSize = 256;
        do
        {
            nSize += 256;
            LPTSTR lpstr = GetBuffer(nSize - 1);
            if(lpstr == NULL)
            {
                nLen = 0;
                break;
            }
            nLen = _LoadString(nID, lpstr, nSize);
        } while (nSize - nLen <= CHAR_FUDGE);
        ReleaseBuffer();

        return (nLen > 0);
    }

#ifndef _UNICODE
    // ANSI <-> OEM support (convert string in place)
    void AnsiToOem()
    {
        CopyBeforeWrite();
        ::AnsiToOem(m_pchData, m_pchData);
    }

    void OemToAnsi()
    {
        CopyBeforeWrite();
        ::OemToAnsi(m_pchData, m_pchData);
    }
#endif

#ifndef _ATL_NO_COM
    // OLE BSTR support (use for OLE automation)
    BSTR AllocSysString() const
    {
#if defined(_UNICODE) || defined(OLE2ANSI)
        BSTR bstr = ::SysAllocStringLen(m_pchData, GetData()->nDataLength);
#else
        int nLen = MultiByteToWideChar(CP_ACP, 0, m_pchData,
            GetData()->nDataLength, NULL, NULL);
        BSTR bstr = ::SysAllocStringLen(NULL, nLen);
        if(bstr != NULL)
            MultiByteToWideChar(CP_ACP, 0, m_pchData, GetData()->nDataLength, bstr, nLen);
#endif
        return bstr;
    }

    BSTR SetSysString(BSTR* pbstr) const
    {
#if defined(_UNICODE) || defined(OLE2ANSI)
        ::SysReAllocStringLen(pbstr, m_pchData, GetData()->nDataLength);
#else
        int nLen = MultiByteToWideChar(CP_ACP, 0, m_pchData,
            GetData()->nDataLength, NULL, NULL);
        if(::SysReAllocStringLen(pbstr, NULL, nLen))
            MultiByteToWideChar(CP_ACP, 0, m_pchData, GetData()->nDataLength, *pbstr, nLen);
#endif
        ATLASSERT(*pbstr != NULL);
        return *pbstr;
    }
#endif // !_ATL_NO_COM

    // Access to string implementation buffer as "C" character array
    LPTSTR GetBuffer(int nMinBufLength)
    {
        ATLASSERT(nMinBufLength >= 0);

        if (GetData()->nRefs > 1 || nMinBufLength > GetData()->nAllocLength)
        {
            // we have to grow the buffer
            CStringData* pOldData = GetData();
            int nOldLen = GetData()->nDataLength;   // AllocBuffer will tromp it
            if (nMinBufLength < nOldLen)
                nMinBufLength = nOldLen;

            if(!AllocBuffer(nMinBufLength))
                return NULL;

            SecureHelper::memcpy_x(m_pchData, (nMinBufLength + 1) * sizeof(TCHAR), pOldData->data(), (nOldLen + 1) * sizeof(TCHAR));
            GetData()->nDataLength = nOldLen;
            CString::Release(pOldData);
        }
        ATLASSERT(GetData()->nRefs <= 1);

        // return a pointer to the character storage for this string
        ATLASSERT(m_pchData != NULL);
        return m_pchData;
    }

    void ReleaseBuffer(int nNewLength = -1)
    {
        CopyBeforeWrite();   // just in case GetBuffer was not called

        if (nNewLength == -1)
            nNewLength = lstrlen(m_pchData);   // zero terminated

        ATLASSERT(nNewLength <= GetData()->nAllocLength);
        GetData()->nDataLength = nNewLength;
        m_pchData[nNewLength] = _T('\0');
    }

    LPTSTR GetBufferSetLength(int nNewLength)
    {
        ATLASSERT(nNewLength >= 0);

        if(GetBuffer(nNewLength) == NULL)
            return NULL;

        GetData()->nDataLength = nNewLength;
        m_pchData[nNewLength] = _T('\0');
        return m_pchData;
    }

    void FreeExtra()
    {
        ATLASSERT(GetData()->nDataLength <= GetData()->nAllocLength);
        if (GetData()->nDataLength != GetData()->nAllocLength)
        {
            CStringData* pOldData = GetData();
            if(AllocBuffer(GetData()->nDataLength))
            {
                SecureHelper::memcpy_x(m_pchData, (GetData()->nAllocLength + 1) * sizeof(TCHAR), pOldData->data(), pOldData->nDataLength * sizeof(TCHAR));
                ATLASSERT(m_pchData[GetData()->nDataLength] == _T('\0'));
                CString::Release(pOldData);
            }
        }
        ATLASSERT(GetData() != NULL);
    }

    // Use LockBuffer/UnlockBuffer to turn refcounting off
    LPTSTR LockBuffer()
    {
        LPTSTR lpsz = GetBuffer(0);
        if(lpsz != NULL)
            GetData()->nRefs = -1;
        return lpsz;
    }

    void UnlockBuffer()
    {
        ATLASSERT(GetData()->nRefs == -1);
        if (GetData() != _atltmpDataNil)
            GetData()->nRefs = 1;
    }

// Implementation
public:
    ~CString()   //  free any attached data
    {
        if (GetData() != _atltmpDataNil)
        {
            if (InterlockedDecrement(&GetData()->nRefs) <= 0)
                delete[] (BYTE*)GetData();
        }
    }

    int GetAllocLength() const
    {
        return GetData()->nAllocLength;
    }

    static BOOL __stdcall _IsValidString(LPCTSTR lpsz, int /*nLength*/ = -1)
    {
        return (lpsz != NULL) ? TRUE : FALSE;
    }

protected:
    LPTSTR m_pchData;   // pointer to ref counted string data

    // implementation helpers
    CStringData* GetData() const
    {
        ATLASSERT(m_pchData != NULL);
        return ((CStringData*)m_pchData) - 1;
    }

    void Init()
    {
        m_pchData = _GetEmptyString().m_pchData;
    }

    BOOL AllocCopy(CString& dest, int nCopyLen, int nCopyIndex, int nExtraLen) const
    {
        // will clone the data attached to this string
        // allocating 'nExtraLen' characters
        // Places results in uninitialized string 'dest'
        // Will copy the part or all of original data to start of new string

        BOOL bRet = FALSE;
        int nNewLen = nCopyLen + nExtraLen;
        if (nNewLen == 0)
        {
            dest.Init();
            bRet = TRUE;
        }
        else if(nNewLen >= nCopyLen)
        {
            if(dest.AllocBuffer(nNewLen))
            {
                SecureHelper::memcpy_x(dest.m_pchData, (nNewLen + 1) * sizeof(TCHAR), m_pchData + nCopyIndex, nCopyLen * sizeof(TCHAR));
                bRet = TRUE;
            }
        }

        return bRet;
    }

    // always allocate one extra character for '\0' termination
    // assumes [optimistically] that data length will equal allocation length
    BOOL AllocBuffer(int nLen)
    {
        ATLASSERT(nLen >= 0);
        ATLASSERT(nLen <= INT_MAX - 1);   // max size (enough room for 1 extra)

        if (nLen == 0)
        {
            Init();
        }
        else
        {
            CStringData* pData = NULL;
            ATLTRY(pData = (CStringData*)new BYTE[sizeof(CStringData) + (nLen + 1) * sizeof(TCHAR)]);
            if(pData == NULL)
                return FALSE;

            pData->nRefs = 1;
            pData->data()[nLen] = _T('\0');
            pData->nDataLength = nLen;
            pData->nAllocLength = nLen;
            m_pchData = pData->data();
        }

        return TRUE;
    }

    // Assignment operators
    //  All assign a new value to the string
    //      (a) first see if the buffer is big enough
    //      (b) if enough room, copy on top of old buffer, set size and type
    //      (c) otherwise free old string data, and create a new one
    //
    //  All routines return the new string (but as a 'const CString&' so that
    //      assigning it again will cause a copy, eg: s1 = s2 = "hi there".
    //
    void AssignCopy(int nSrcLen, LPCTSTR lpszSrcData)
    {
        if(AllocBeforeWrite(nSrcLen))
        {
            SecureHelper::memcpy_x(m_pchData, (nSrcLen + 1) * sizeof(TCHAR), lpszSrcData, nSrcLen * sizeof(TCHAR));
            GetData()->nDataLength = nSrcLen;
            m_pchData[nSrcLen] = _T('\0');
        }
    }

    // Concatenation
    // NOTE: "operator +" is done as friend functions for simplicity
    //      There are three variants:
    //          CString + CString
    // and for ? = TCHAR, LPCTSTR
    //          CString + ?
    //          ? + CString
    BOOL ConcatCopy(int nSrc1Len, LPCTSTR lpszSrc1Data, int nSrc2Len, LPCTSTR lpszSrc2Data)
    {
        // -- master concatenation routine
        // Concatenate two sources
        // -- assume that 'this' is a new CString object

        BOOL bRet = TRUE;
        int nNewLen = nSrc1Len + nSrc2Len;
        if(nNewLen < nSrc1Len || nNewLen < nSrc2Len)
        {
            bRet = FALSE;
        }
        else if(nNewLen != 0)
        {
            bRet = AllocBuffer(nNewLen);
            if (bRet)
            {
                SecureHelper::memcpy_x(m_pchData, (nNewLen + 1) * sizeof(TCHAR), lpszSrc1Data, nSrc1Len * sizeof(TCHAR));
                SecureHelper::memcpy_x(m_pchData + nSrc1Len, (nNewLen + 1 - nSrc1Len) * sizeof(TCHAR), lpszSrc2Data, nSrc2Len * sizeof(TCHAR));
            }
        }
        return bRet;
    }

    void ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData)
    {
        //  -- the main routine for += operators

        // concatenating an empty string is a no-op!
        if (nSrcLen == 0)
            return;

        // if the buffer is too small, or we have a width mis-match, just
        //   allocate a new buffer (slow but sure)
        if (GetData()->nRefs > 1 || GetData()->nDataLength + nSrcLen > GetData()->nAllocLength)
        {
            // we have to grow the buffer, use the ConcatCopy routine
            CStringData* pOldData = GetData();
            if (ConcatCopy(GetData()->nDataLength, m_pchData, nSrcLen, lpszSrcData))
            {
                ATLASSERT(pOldData != NULL);
                CString::Release(pOldData);
            }
        }
        else
        {
            // fast concatenation when buffer big enough
            SecureHelper::memcpy_x(m_pchData + GetData()->nDataLength, (GetData()->nAllocLength + 1) * sizeof(TCHAR), lpszSrcData, nSrcLen * sizeof(TCHAR));
            GetData()->nDataLength += nSrcLen;
            ATLASSERT(GetData()->nDataLength <= GetData()->nAllocLength);
            m_pchData[GetData()->nDataLength] = _T('\0');
        }
    }

    void CopyBeforeWrite()
    {
        if (GetData()->nRefs > 1)
        {
            CStringData* pData = GetData();
            Release();
            if(AllocBuffer(pData->nDataLength))
                SecureHelper::memcpy_x(m_pchData, (GetData()->nAllocLength + 1) * sizeof(TCHAR), pData->data(), (pData->nDataLength + 1) * sizeof(TCHAR));
        }
        ATLASSERT(GetData()->nRefs <= 1);
    }

    BOOL AllocBeforeWrite(int nLen)
    {
        BOOL bRet = TRUE;
        if (GetData()->nRefs > 1 || nLen > GetData()->nAllocLength)
        {
            Release();
            bRet = AllocBuffer(nLen);
        }
        ATLASSERT(GetData()->nRefs <= 1);
        return bRet;
    }

    void Release()
    {
        if (GetData() != _atltmpDataNil)
        {
            ATLASSERT(GetData()->nRefs != 0);
            if (InterlockedDecrement(&GetData()->nRefs) <= 0)
                delete[] (BYTE*)GetData();
            Init();
        }
    }

    static void PASCAL Release(CStringData* pData)
    {
        if (pData != _atltmpDataNil)
        {
            ATLASSERT(pData->nRefs != 0);
            if (InterlockedDecrement(&pData->nRefs) <= 0)
                delete[] (BYTE*)pData;
        }
    }

    static int PASCAL SafeStrlen(LPCTSTR lpsz)
    {
        return (lpsz == NULL) ? 0 : lstrlen(lpsz);
    }

    static int __stdcall _LoadString(UINT nID, LPTSTR lpszBuf, UINT nMaxBuf)
    {
#ifdef _DEBUG
        // LoadString without annoying warning from the Debug kernel if the
        //  segment containing the string is not present
        if (::FindResource(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE((nID >> 4) + 1), RT_STRING) == NULL)
        {
            lpszBuf[0] = _T('\0');
            return 0;   // not found
        }
#endif // _DEBUG

        int nLen = ::LoadString(ModuleHelper::GetResourceInstance(), nID, lpszBuf, nMaxBuf);
        if (nLen == 0)
            lpszBuf[0] = _T('\0');

        return nLen;
    }

    static const CString& __stdcall _GetEmptyString()
    {
        return *(CString*)&_atltmpPchNil;
    }

// CString conversion helpers
    static int __cdecl _wcstombsz(char* mbstr, const wchar_t* wcstr, size_t count)
    {
        if (count == 0 && mbstr != NULL)
            return 0;

        int result = ::WideCharToMultiByte(CP_ACP, 0, wcstr, -1, mbstr, (int)count, NULL, NULL);
        ATLASSERT(mbstr == NULL || result <= (int)count);
        if ((mbstr != NULL) && (result > 0))
            mbstr[result - 1] = 0;
        return result;
    }

    static int __cdecl _mbstowcsz(wchar_t* wcstr, const char* mbstr, size_t count)
    {
        if (count == 0 && wcstr != NULL)
            return 0;

        int result = ::MultiByteToWideChar(CP_ACP, 0, mbstr, -1, wcstr, (int)count);
        ATLASSERT(wcstr == NULL || result <= (int)count);
        if ((wcstr != NULL) && (result > 0))
            wcstr[result - 1] = 0;
        return result;
    }

// Helpers to avoid CRT startup code
#ifdef _ATL_MIN_CRT
    static const TCHAR* _cstrchr(const TCHAR* p, TCHAR ch)
    {
        // strchr for '\0' should succeed
        while (*p != 0)
        {
            if (*p == ch)
                break;
            p = ::CharNext(p);
        }
        return (*p == ch) ? p : NULL;
    }

    static TCHAR* _cstrrev(TCHAR* pStr)
    {
        // optimize NULL, zero-length, and single-char case
        if ((pStr == NULL) || (pStr[0] == _T('\0')) || (pStr[1] == _T('\0')))
            return pStr;

        TCHAR* p = pStr;

        while (*p != 0) 
        {
            TCHAR* pNext = ::CharNext(p);
            if(pNext > p + 1)
            {
                char p1 = *(char*)p;
                *(char*)p = *(char*)(p + 1);
                *(char*)(p + 1) = p1;
            }
            p = pNext;
        }

        p--;
        TCHAR* q = pStr;

        while (q < p)
        {
            TCHAR t = *q;
            *q = *p;
            *p = t;
            q++;
            p--;
        }
        return pStr;
    }

    static const TCHAR* _cstrstr(const TCHAR* pStr, const TCHAR* pCharSet)
    {
        int nLen = lstrlen(pCharSet);
        if (nLen == 0)
            return (TCHAR*)pStr;

        const TCHAR* pRet = NULL;
        const TCHAR* pCur = pStr;
        while((pCur = _cstrchr(pCur, *pCharSet)) != NULL)
        {
            if(memcmp(pCur, pCharSet, nLen * sizeof(TCHAR)) == 0)
            {
                pRet = pCur;
                break;
            }
            pCur = ::CharNext(pCur);
        }
        return pRet;
    }

    static int _cstrspn(const TCHAR* pStr, const TCHAR* pCharSet)
    {
        int nRet = 0;
        const TCHAR* p = pStr;
        while (*p != 0)
        {
            const TCHAR* pNext = ::CharNext(p);
            if(pNext > p + 1)
            {
                if(_cstrchr_db(pCharSet, *p, *(p + 1)) == NULL)
                    break;
                nRet += 2;
            }
            else
            {
                if(_cstrchr(pCharSet, *p) == NULL)
                    break;
                nRet++;
            }
            p = pNext;
        }
        return nRet;
    }

    static int _cstrcspn(const TCHAR* pStr, const TCHAR* pCharSet)
    {
        int nRet = 0;
        TCHAR* p = (TCHAR*)pStr;
        while (*p != 0)
        {
            TCHAR* pNext = ::CharNext(p);
            if(pNext > p + 1)
            {
                if(_cstrchr_db(pCharSet, *p, *(p + 1)) != NULL)
                    break;
                nRet += 2;
            }
            else
            {
                if(_cstrchr(pCharSet, *p) != NULL)
                    break;
                nRet++;
            }
            p = pNext;
        }
        return nRet;
    }

    static const TCHAR* _cstrpbrk(const TCHAR* p, const TCHAR* lpszCharSet)
    {
        int n = _cstrcspn(p, lpszCharSet);
        return (p[n] != 0) ? &p[n] : NULL;
    }

    static int _cstrcmp(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        return lstrcmp(pstrOne, pstrOther);
    }

    static int _cstrcmpi(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        return lstrcmpi(pstrOne, pstrOther);
    }

    static int _cstrcoll(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        int nRet = CompareString(GetThreadLocale(), 0, pstrOne, -1, pstrOther, -1);
        ATLASSERT(nRet != 0);
        return nRet - 2;   // convert to strcmp convention
    }

    static int _cstrcolli(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        int nRet = CompareString(GetThreadLocale(), NORM_IGNORECASE, pstrOne, -1, pstrOther, -1);
        ATLASSERT(nRet != 0);
        return nRet - 2;   // convert to strcmp convention
    }
#else // !_ATL_MIN_CRT
    static const TCHAR* _cstrchr(const TCHAR* p, TCHAR ch)
    {
        return _tcschr(p, ch);
    }

    static TCHAR* _cstrrev(TCHAR* pStr)
    {
        return _tcsrev(pStr);
    }

    static const TCHAR* _cstrstr(const TCHAR* pStr, const TCHAR* pCharSet)
    {
        return _tcsstr(pStr, pCharSet);
    }

    static int _cstrspn(const TCHAR* pStr, const TCHAR* pCharSet)
    {
        return (int)_tcsspn(pStr, pCharSet);
    }

    static int _cstrcspn(const TCHAR* pStr, const TCHAR* pCharSet)
    {
        return (int)_tcscspn(pStr, pCharSet);
    }

    static const TCHAR* _cstrpbrk(const TCHAR* p, const TCHAR* lpszCharSet)
    {
        return _tcspbrk(p, lpszCharSet);
    }

    static int _cstrcmp(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        return _tcscmp(pstrOne, pstrOther);
    }

    static int _cstrcmpi(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        return _tcsicmp(pstrOne, pstrOther);
    }

#ifndef _WIN32_WCE
    static int _cstrcoll(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        return _tcscoll(pstrOne, pstrOther);
    }

    static int _cstrcolli(const TCHAR* pstrOne, const TCHAR* pstrOther)
    {
        return _tcsicoll(pstrOne, pstrOther);
    }
#endif // !_WIN32_WCE
#endif // !_ATL_MIN_CRT

    static const TCHAR* _cstrrchr(const TCHAR* p, TCHAR ch)
    {
        return MinCrtHelper::_strrchr(p, ch);
    }

    static int _cstrisdigit(TCHAR ch)
    {
        return MinCrtHelper::_isdigit(ch);
    }

    static int _cstrisspace(TCHAR ch)
    {
        return MinCrtHelper::_isspace(ch);
    }

    static int _cstrtoi(const TCHAR* nptr)
    {
        return MinCrtHelper::_atoi(nptr);
    }

    static const TCHAR* _cstrchr_db(const TCHAR* p, TCHAR ch1, TCHAR ch2)
    {
        const TCHAR* lpsz = NULL;
        while (*p != 0)
        {
            if (*p == ch1 && *(p + 1) == ch2)
            {
                lpsz = p;
                break;
            }
            p = ::CharNext(p);
        }
        return lpsz;
    }
};


// Compare helpers

inline bool __stdcall operator ==(const CString& s1, const CString& s2)
{ return s1.Compare(s2) == 0; }

inline bool __stdcall operator ==(const CString& s1, LPCTSTR s2)
{ return s1.Compare(s2) == 0; }

inline bool __stdcall operator ==(LPCTSTR s1, const CString& s2)
{ return s2.Compare(s1) == 0; }

inline bool __stdcall operator !=(const CString& s1, const CString& s2)
{ return s1.Compare(s2) != 0; }

inline bool __stdcall operator !=(const CString& s1, LPCTSTR s2)
{ return s1.Compare(s2) != 0; }

inline bool __stdcall operator !=(LPCTSTR s1, const CString& s2)
{ return s2.Compare(s1) != 0; }

inline bool __stdcall operator <(const CString& s1, const CString& s2)
{ return s1.Compare(s2) < 0; }

inline bool __stdcall operator <(const CString& s1, LPCTSTR s2)
{ return s1.Compare(s2) < 0; }

inline bool __stdcall operator <(LPCTSTR s1, const CString& s2)
{ return s2.Compare(s1) > 0; }

inline bool __stdcall operator >(const CString& s1, const CString& s2)
{ return s1.Compare(s2) > 0; }

inline bool __stdcall operator >(const CString& s1, LPCTSTR s2)
{ return s1.Compare(s2) > 0; }

inline bool __stdcall operator >(LPCTSTR s1, const CString& s2)
{ return s2.Compare(s1) < 0; }

inline bool __stdcall operator <=(const CString& s1, const CString& s2)
{ return s1.Compare(s2) <= 0; }

inline bool __stdcall operator <=(const CString& s1, LPCTSTR s2)
{ return s1.Compare(s2) <= 0; }

inline bool __stdcall operator <=(LPCTSTR s1, const CString& s2)
{ return s2.Compare(s1) >= 0; }

inline bool __stdcall operator >=(const CString& s1, const CString& s2)
{ return s1.Compare(s2) >= 0; }

inline bool __stdcall operator >=(const CString& s1, LPCTSTR s2)
{ return s1.Compare(s2) >= 0; }

inline bool __stdcall operator >=(LPCTSTR s1, const CString& s2)
{ return s2.Compare(s1) <= 0; }


// CString "operator +" functions

inline CString __stdcall operator +(const CString& string1, const CString& string2)
{
    CString s;
    s.ConcatCopy(string1.GetData()->nDataLength, string1.m_pchData, string2.GetData()->nDataLength, string2.m_pchData);
    return s;
}

inline CString __stdcall operator +(const CString& string, TCHAR ch)
{
    CString s;
    s.ConcatCopy(string.GetData()->nDataLength, string.m_pchData, 1, &ch);
    return s;
}

inline CString __stdcall operator +(TCHAR ch, const CString& string)
{
    CString s;
    s.ConcatCopy(1, &ch, string.GetData()->nDataLength, string.m_pchData);
    return s;
}

#ifdef _UNICODE
inline CString __stdcall operator +(const CString& string, char ch)
{
    return string + (TCHAR)ch;
}

inline CString __stdcall operator +(char ch, const CString& string)
{
    return (TCHAR)ch + string;
}
#endif // _UNICODE

inline CString __stdcall operator +(const CString& string, LPCTSTR lpsz)
{
    ATLASSERT(lpsz == NULL || CString::_IsValidString(lpsz));
    CString s;
    s.ConcatCopy(string.GetData()->nDataLength, string.m_pchData, CString::SafeStrlen(lpsz), lpsz);
    return s;
}

inline CString __stdcall operator +(LPCTSTR lpsz, const CString& string)
{
    ATLASSERT(lpsz == NULL || CString::_IsValidString(lpsz));
    CString s;
    s.ConcatCopy(CString::SafeStrlen(lpsz), lpsz, string.GetData()->nDataLength, string.m_pchData);
    return s;
}

#endif // !_WTL_NO_CSTRING


// CRecentDocumentList - MRU List Support

#ifndef _WIN32_WCE

#ifndef _WTL_MRUEMPTY_TEXT
  #define _WTL_MRUEMPTY_TEXT    _T("(empty)")
#endif

// forward declaration
inline bool AtlCompactPath(LPTSTR lpstrOut, LPCTSTR lpstrIn, int cchLen);

template <class T, int t_cchItemLen = MAX_PATH, int t_nFirstID = ID_FILE_MRU_FIRST, int t_nLastID = ID_FILE_MRU_LAST>
class CRecentDocumentListBase
{
public:
// Declarations
    struct _DocEntry
    {
        TCHAR szDocName[t_cchItemLen];
        bool operator ==(const _DocEntry& de) const
        { return (lstrcmpi(szDocName, de.szDocName) == 0); }
    };

    enum
    {
        m_nMaxEntries_Min = 2,
        m_nMaxEntries_Max = t_nLastID - t_nFirstID + 1,
        m_cchMaxItemLen_Min = 6,
        m_cchMaxItemLen_Max = t_cchItemLen,
        m_cchItemNameLen = 11
    };

// Data members
    ATL::CSimpleArray<_DocEntry> m_arrDocs;
    int m_nMaxEntries;   // default is 4
    HMENU m_hMenu;

    TCHAR m_szNoEntries[t_cchItemLen];

    int m_cchMaxItemLen;

// Constructor
    CRecentDocumentListBase() : m_hMenu(NULL), m_nMaxEntries(4), m_cchMaxItemLen(-1)
    {
        // These ASSERTs verify values of the template arguments
        ATLASSERT(t_cchItemLen > m_cchMaxItemLen_Min);
        ATLASSERT(m_nMaxEntries_Max > m_nMaxEntries_Min);
    }

// Attributes
    HMENU GetMenuHandle() const
    {
        return m_hMenu;
    }

    void SetMenuHandle(HMENU hMenu)
    {
        ATLASSERT(hMenu == NULL || ::IsMenu(hMenu));
        m_hMenu = hMenu;
        if(m_hMenu == NULL || (::GetMenuString(m_hMenu, t_nFirstID, m_szNoEntries, t_cchItemLen, MF_BYCOMMAND) == 0))
        {
            T* pT = static_cast<T*>(this);
            pT;   // avoid level 4 warning
            SecureHelper::strncpy_x(m_szNoEntries, _countof(m_szNoEntries), pT->GetMRUEmptyText(), _TRUNCATE);
        }
    }

    int GetMaxEntries() const
    {
        return m_nMaxEntries;
    }

    void SetMaxEntries(int nMaxEntries)
    {
        ATLASSERT(nMaxEntries >= m_nMaxEntries_Min && nMaxEntries <= m_nMaxEntries_Max);
        if(nMaxEntries < m_nMaxEntries_Min)
            nMaxEntries = m_nMaxEntries_Min;
        else if(nMaxEntries > m_nMaxEntries_Max)
            nMaxEntries = m_nMaxEntries_Max;
        m_nMaxEntries = nMaxEntries;
    }

    int GetMaxItemLength() const
    {
        return m_cchMaxItemLen;
    }

    void SetMaxItemLength(int cchMaxLen)
    {
        ATLASSERT((cchMaxLen >= m_cchMaxItemLen_Min && cchMaxLen <= m_cchMaxItemLen_Max) || cchMaxLen == -1);
        if(cchMaxLen != -1)
        {
            if(cchMaxLen < m_cchMaxItemLen_Min)
                cchMaxLen = m_cchMaxItemLen_Min;
            else if(cchMaxLen > m_cchMaxItemLen_Max)
                cchMaxLen = m_cchMaxItemLen_Max;
        }
        m_cchMaxItemLen = cchMaxLen;
        T* pT = static_cast<T*>(this);
        pT->UpdateMenu();
    }

// Operations
    BOOL AddToList(LPCTSTR lpstrDocName)
    {
        _DocEntry de;
        errno_t nRet = SecureHelper::strncpy_x(de.szDocName, _countof(de.szDocName), lpstrDocName, _TRUNCATE);
        if(nRet != 0 && nRet != STRUNCATE)
            return FALSE;

        for(int i = 0; i < m_arrDocs.GetSize(); i++)
        {
            if(lstrcmpi(m_arrDocs[i].szDocName, lpstrDocName) == 0)
            {
                m_arrDocs.RemoveAt(i);
                break;
            }
        }

        if(m_arrDocs.GetSize() == m_nMaxEntries)
            m_arrDocs.RemoveAt(0);

        BOOL bRet = m_arrDocs.Add(de);
        if(bRet)
        {
            T* pT = static_cast<T*>(this);
            bRet = pT->UpdateMenu();
        }
        return bRet;
    }

    // This function is deprecated because it is not safe. 
    // Use the version below that accepts the buffer length.
#if (_MSC_VER >= 1300)
    __declspec(deprecated)
#endif
    BOOL GetFromList(int /*nItemID*/, LPTSTR /*lpstrDocName*/)
    {
        ATLASSERT(FALSE);
        return FALSE;
    }

    BOOL GetFromList(int nItemID, LPTSTR lpstrDocName, int cchLength)
    {
        int nIndex = m_arrDocs.GetSize() - (nItemID - t_nFirstID) - 1;
        if(nIndex < 0 || nIndex >= m_arrDocs.GetSize())
            return FALSE;
        if(lstrlen(m_arrDocs[nIndex].szDocName) >= cchLength)
            return FALSE;
        SecureHelper::strcpy_x(lpstrDocName, cchLength, m_arrDocs[nIndex].szDocName);

        return TRUE;
    }

#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
    BOOL GetFromList(int nItemID, _CSTRING_NS::CString& strDocName)
    {
        int nIndex = m_arrDocs.GetSize() - (nItemID - t_nFirstID) - 1;
        if(nIndex < 0 || nIndex >= m_arrDocs.GetSize())
            return FALSE;
        strDocName = m_arrDocs[nIndex].szDocName;
        return TRUE;
    }
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)

    BOOL RemoveFromList(int nItemID)
    {
        int nIndex = m_arrDocs.GetSize() - (nItemID - t_nFirstID) - 1;
        BOOL bRet = m_arrDocs.RemoveAt(nIndex);
        if(bRet)
        {
            T* pT = static_cast<T*>(this);
            bRet = pT->UpdateMenu();
        }
        return bRet;
    }

    BOOL MoveToTop(int nItemID)
    {
        int nIndex = m_arrDocs.GetSize() - (nItemID - t_nFirstID) - 1;
        if(nIndex < 0 || nIndex >= m_arrDocs.GetSize())
            return FALSE;
        _DocEntry de;
        de = m_arrDocs[nIndex];
        m_arrDocs.RemoveAt(nIndex);
        BOOL bRet = m_arrDocs.Add(de);
        if(bRet)
        {
            T* pT = static_cast<T*>(this);
            bRet = pT->UpdateMenu();
        }
        return bRet;
    }

    BOOL ReadFromRegistry(LPCTSTR lpstrRegKey)
    {
        T* pT = static_cast<T*>(this);
        CRegKeyEx rkParent;
        CRegKeyEx rk;

        LONG lRet = rkParent.Open(HKEY_CURRENT_USER, lpstrRegKey);
        if(lRet != ERROR_SUCCESS)
            return FALSE;
        lRet = rk.Open(rkParent, pT->GetRegKeyName());
        if(lRet != ERROR_SUCCESS)
            return FALSE;

        DWORD dwRet = 0;
        lRet = rk.QueryDWORDValue(pT->GetRegCountName(), dwRet);
        if(lRet != ERROR_SUCCESS)
            return FALSE;
        SetMaxEntries(dwRet);

        m_arrDocs.RemoveAll();

        TCHAR szRetString[t_cchItemLen] = { 0 };
        _DocEntry de;

        for(int nItem = m_nMaxEntries; nItem > 0; nItem--)
        {
            TCHAR szBuff[m_cchItemNameLen] = { 0 };
            SecureHelper::wsprintf_x(szBuff, m_cchItemNameLen, pT->GetRegItemName(), nItem);
            ULONG ulCount = t_cchItemLen;
            lRet = rk.QueryStringValue(szBuff, szRetString, &ulCount);
            if(lRet == ERROR_SUCCESS)
            {
                SecureHelper::strcpy_x(de.szDocName, _countof(de.szDocName), szRetString);
                m_arrDocs.Add(de);
            }
        }

        rk.Close();
        rkParent.Close();

        return pT->UpdateMenu();
    }

    BOOL WriteToRegistry(LPCTSTR lpstrRegKey)
    {
        T* pT = static_cast<T*>(this);
        pT;   // avoid level 4 warning
        CRegKeyEx rkParent;
        CRegKeyEx rk;

        LONG lRet = rkParent.Create(HKEY_CURRENT_USER, lpstrRegKey);
        if(lRet != ERROR_SUCCESS)
            return FALSE;
        lRet = rk.Create(rkParent, pT->GetRegKeyName());
        if(lRet != ERROR_SUCCESS)
            return FALSE;

        lRet = rk.SetDWORDValue(pT->GetRegCountName(), m_nMaxEntries);
        ATLASSERT(lRet == ERROR_SUCCESS);

        // set new values
        int nItem;
        for(nItem = m_arrDocs.GetSize(); nItem > 0; nItem--)
        {
            TCHAR szBuff[m_cchItemNameLen] = { 0 };
            SecureHelper::wsprintf_x(szBuff, m_cchItemNameLen, pT->GetRegItemName(), nItem);
            TCHAR szDocName[t_cchItemLen] = { 0 };
            GetFromList(t_nFirstID + nItem - 1, szDocName, t_cchItemLen);
            lRet = rk.SetStringValue(szBuff, szDocName);
            ATLASSERT(lRet == ERROR_SUCCESS);
        }

        // delete unused keys
        for(nItem = m_arrDocs.GetSize() + 1; nItem <= m_nMaxEntries_Max; nItem++)
        {
            TCHAR szBuff[m_cchItemNameLen] = { 0 };
            SecureHelper::wsprintf_x(szBuff, m_cchItemNameLen, pT->GetRegItemName(), nItem);
            rk.DeleteValue(szBuff);
        }

        rk.Close();
        rkParent.Close();

        return TRUE;
    }

// Implementation
    BOOL UpdateMenu()
    {
        if(m_hMenu == NULL)
            return FALSE;
        ATLASSERT(::IsMenu(m_hMenu));

        int nItems = ::GetMenuItemCount(m_hMenu);
        int nInsertPoint = 0;
        for(int i = 0; i < nItems; i++)
        {
            CMenuItemInfo mi;
            mi.fMask = MIIM_ID;
            ::GetMenuItemInfo(m_hMenu, i, TRUE, &mi);
            if (mi.wID == t_nFirstID)
            {
                nInsertPoint = i;
                break;
            }
        }

        ATLASSERT(nInsertPoint < nItems && "You need a menu item with an ID = t_nFirstID");

        for(int j = t_nFirstID; j < (t_nFirstID + m_nMaxEntries); j++)
        {
            // keep the first one as an insertion point
            if (j != t_nFirstID)
                ::DeleteMenu(m_hMenu, j, MF_BYCOMMAND);
        }

        TCHAR szItemText[t_cchItemLen + 6] = { 0 };   // add space for &, 2 digits, and a space
        int nSize = m_arrDocs.GetSize();
        int nItem = 0;
        if(nSize > 0)
        {
            for(nItem = 0; nItem < nSize; nItem++)
            {
                if(m_cchMaxItemLen == -1)
                {
                    SecureHelper::wsprintf_x(szItemText, t_cchItemLen + 6, _T("&%i %s"), nItem + 1, m_arrDocs[nSize - 1 - nItem].szDocName);
                }
                else
                {
                    TCHAR szBuff[t_cchItemLen] = { 0 };
                    T* pT = static_cast<T*>(this);
                    pT;   // avoid level 4 warning
                    bool bRet = pT->CompactDocumentName(szBuff, m_arrDocs[nSize - 1 - nItem].szDocName, m_cchMaxItemLen);
                    bRet;   // avoid level 4 warning
                    ATLASSERT(bRet);
                    SecureHelper::wsprintf_x(szItemText, t_cchItemLen + 6, _T("&%i %s"), nItem + 1, szBuff);
                }

                ::InsertMenu(m_hMenu, nInsertPoint + nItem, MF_BYPOSITION | MF_STRING, t_nFirstID + nItem, szItemText);
            }
        }
        else    // empty
        {
            ::InsertMenu(m_hMenu, nInsertPoint, MF_BYPOSITION | MF_STRING, t_nFirstID, m_szNoEntries);
            ::EnableMenuItem(m_hMenu, t_nFirstID, MF_GRAYED);
            nItem++;
        }
        ::DeleteMenu(m_hMenu, nInsertPoint + nItem, MF_BYPOSITION);

        return TRUE;
    }

// Overrideables
    // override to provide a different method of compacting document names
    static bool CompactDocumentName(LPTSTR lpstrOut, LPCTSTR lpstrIn, int cchLen)
    {
        return AtlCompactPath(lpstrOut, lpstrIn, cchLen);
    }

    static LPCTSTR GetRegKeyName()
    {
        return _T("Recent Document List");
    }

    static LPCTSTR GetRegCountName()
    {
        return _T("DocumentCount");
    }

    static LPCTSTR GetRegItemName()
    {
        // Note: This string is a format string used with wsprintf().
        // Resulting formatted string must be m_cchItemNameLen or less 
        // characters long, including the terminating null character.
        return _T("Document%i");
    }

    static LPCTSTR GetMRUEmptyText()
    {
        return _WTL_MRUEMPTY_TEXT;
    }
};

class CRecentDocumentList : public CRecentDocumentListBase<CRecentDocumentList>
{
public:
// nothing here
};

#endif // _WIN32_WCE


// CFindFile - file search helper class

class CFindFile
{
public:
// Data members
    WIN32_FIND_DATA m_fd;
    TCHAR m_lpszRoot[MAX_PATH];
    TCHAR m_chDirSeparator;
    HANDLE m_hFind;
    BOOL m_bFound;

// Constructor/destructor
    CFindFile() : m_hFind(NULL), m_chDirSeparator(_T('\\')), m_bFound(FALSE)
    { }

    ~CFindFile()
    {
        Close();
    }

// Attributes
    ULONGLONG GetFileSize() const
    {
        ATLASSERT(m_hFind != NULL);

        ULARGE_INTEGER nFileSize = { 0 };

        if(m_bFound)
        {
            nFileSize.LowPart = m_fd.nFileSizeLow;
            nFileSize.HighPart = m_fd.nFileSizeHigh;
        }
        else
        {
            nFileSize.QuadPart = 0;
        }

        return nFileSize.QuadPart;
    }

    BOOL GetFileName(LPTSTR lpstrFileName, int cchLength) const
    {
        ATLASSERT(m_hFind != NULL);
        if(lstrlen(m_fd.cFileName) >= cchLength)
            return FALSE;

        if(m_bFound)
            SecureHelper::strcpy_x(lpstrFileName, cchLength, m_fd.cFileName);

        return m_bFound;
    }

    BOOL GetFilePath(LPTSTR lpstrFilePath, int cchLength) const
    {
        ATLASSERT(m_hFind != NULL);

        int nLen = lstrlen(m_lpszRoot);
#ifndef _WIN32_WCE
        ATLASSERT(nLen > 0);
        if(nLen == 0)
            return FALSE;

        bool bAddSep = (m_lpszRoot[nLen - 1] != _T('\\') && m_lpszRoot[nLen - 1] !=_T('/'));
#else // CE specific
        // allow diskless devices (nLen == 0)
        bool bAddSep = ((nLen == 0) || (m_lpszRoot[nLen - 1] != _T('\\') && m_lpszRoot[nLen - 1] !=_T('/')));
#endif // _WIN32_WCE

        if((lstrlen(m_lpszRoot) + (bAddSep ?  1 : 0)) >= cchLength)
            return FALSE;

        SecureHelper::strcpy_x(lpstrFilePath, cchLength, m_lpszRoot);

        if(bAddSep)
        {
            TCHAR szSeparator[2] = { m_chDirSeparator, 0 };
            SecureHelper::strcat_x(lpstrFilePath, cchLength, szSeparator);
        }

        SecureHelper::strcat_x(lpstrFilePath, cchLength, m_fd.cFileName);

        return TRUE;
    }

#ifndef _WIN32_WCE
    BOOL GetFileTitle(LPTSTR lpstrFileTitle, int cchLength) const
    {
        ATLASSERT(m_hFind != NULL);

        TCHAR szBuff[MAX_PATH] = { 0 };
        if(!GetFileName(szBuff, MAX_PATH))
            return FALSE;

        if(lstrlen(szBuff) >= cchLength || cchLength < 1)
            return FALSE;

        // find the last dot
        LPTSTR pstrDot  = MinCrtHelper::_strrchr(szBuff, _T('.'));
        if(pstrDot != NULL)
            *pstrDot = 0;

        SecureHelper::strcpy_x(lpstrFileTitle, cchLength, szBuff);

        return TRUE;
    }
#endif // !_WIN32_WCE

    BOOL GetFileURL(LPTSTR lpstrFileURL, int cchLength) const
    {
        ATLASSERT(m_hFind != NULL);

        TCHAR szBuff[MAX_PATH] = { 0 };
        if(!GetFilePath(szBuff, MAX_PATH))
            return FALSE;
        LPCTSTR lpstrFileURLPrefix = _T("file://");
        if(lstrlen(szBuff) + lstrlen(lpstrFileURLPrefix) >= cchLength)
            return FALSE;
        SecureHelper::strcpy_x(lpstrFileURL, cchLength, lpstrFileURLPrefix);
        SecureHelper::strcat_x(lpstrFileURL, cchLength, szBuff);

        return TRUE;
    }

    BOOL GetRoot(LPTSTR lpstrRoot, int cchLength) const
    {
        ATLASSERT(m_hFind != NULL);
        if(lstrlen(m_lpszRoot) >= cchLength)
            return FALSE;

        SecureHelper::strcpy_x(lpstrRoot, cchLength, m_lpszRoot);

        return TRUE;
    }

#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
    _CSTRING_NS::CString GetFileName() const
    {
        ATLASSERT(m_hFind != NULL);

        _CSTRING_NS::CString ret;

        if(m_bFound)
            ret = m_fd.cFileName;
        return ret;
    }

    _CSTRING_NS::CString GetFilePath() const
    {
        ATLASSERT(m_hFind != NULL);

        _CSTRING_NS::CString strResult = m_lpszRoot;
        int nLen = strResult.GetLength();
#ifndef _WIN32_WCE
        ATLASSERT(nLen > 0);
        if(nLen == 0)
            return strResult;

        if((strResult[nLen - 1] != _T('\\')) && (strResult[nLen - 1] != _T('/')))
#else // CE specific
        // allow diskless devices (nLen == 0)
        if((nLen == 0) || ((strResult[nLen - 1] != _T('\\')) && (strResult[nLen - 1] != _T('/'))))
#endif // _WIN32_WCE
            strResult += m_chDirSeparator;
        strResult += GetFileName();
        return strResult;
    }

#ifndef _WIN32_WCE
    _CSTRING_NS::CString GetFileTitle() const
    {
        ATLASSERT(m_hFind != NULL);

        _CSTRING_NS::CString strResult;
        GetFileTitle(strResult.GetBuffer(MAX_PATH), MAX_PATH);
        strResult.ReleaseBuffer();

        return strResult;
    }
#endif // !_WIN32_WCE

    _CSTRING_NS::CString GetFileURL() const
    {
        ATLASSERT(m_hFind != NULL);

        _CSTRING_NS::CString strResult("file://");
        strResult += GetFilePath();
        return strResult;
    }

    _CSTRING_NS::CString GetRoot() const
    {
        ATLASSERT(m_hFind != NULL);

        _CSTRING_NS::CString str = m_lpszRoot;
        return str;
    }
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)

    BOOL GetLastWriteTime(FILETIME* pTimeStamp) const
    {
        ATLASSERT(m_hFind != NULL);
        ATLASSERT(pTimeStamp != NULL);

        if(m_bFound && pTimeStamp != NULL)
        {
            *pTimeStamp = m_fd.ftLastWriteTime;
            return TRUE;
        }

        return FALSE;
    }

    BOOL GetLastAccessTime(FILETIME* pTimeStamp) const
    {
        ATLASSERT(m_hFind != NULL);
        ATLASSERT(pTimeStamp != NULL);

        if(m_bFound && pTimeStamp != NULL)
        {
            *pTimeStamp = m_fd.ftLastAccessTime;
            return TRUE;
        }

        return FALSE;
    }

    BOOL GetCreationTime(FILETIME* pTimeStamp) const
    {
        ATLASSERT(m_hFind != NULL);

        if(m_bFound && pTimeStamp != NULL)
        {
            *pTimeStamp = m_fd.ftCreationTime;
            return TRUE;
        }

        return FALSE;
    }

    BOOL MatchesMask(DWORD dwMask) const
    {
        ATLASSERT(m_hFind != NULL);

        if(m_bFound)
            return ((m_fd.dwFileAttributes & dwMask) != 0);

        return FALSE;
    }

    BOOL IsDots() const
    {
        ATLASSERT(m_hFind != NULL);

        // return TRUE if the file name is "." or ".." and
        // the file is a directory

        BOOL bResult = FALSE;
        if(m_bFound && IsDirectory())
        {
            if(m_fd.cFileName[0] == _T('.') && (m_fd.cFileName[1] == _T('\0') || (m_fd.cFileName[1] == _T('.') && m_fd.cFileName[2] == _T('\0'))))
                bResult = TRUE;
        }

        return bResult;
    }

    BOOL IsReadOnly() const
    {
        return MatchesMask(FILE_ATTRIBUTE_READONLY);
    }

    BOOL IsDirectory() const
    {
        return MatchesMask(FILE_ATTRIBUTE_DIRECTORY);
    }

    BOOL IsCompressed() const
    {
        return MatchesMask(FILE_ATTRIBUTE_COMPRESSED);
    }

    BOOL IsSystem() const
    {
        return MatchesMask(FILE_ATTRIBUTE_SYSTEM);
    }

    BOOL IsHidden() const
    {
        return MatchesMask(FILE_ATTRIBUTE_HIDDEN);
    }

    BOOL IsTemporary() const
    {
        return MatchesMask(FILE_ATTRIBUTE_TEMPORARY);
    }

    BOOL IsNormal() const
    {
        return MatchesMask(FILE_ATTRIBUTE_NORMAL);
    }

    BOOL IsArchived() const
    {
        return MatchesMask(FILE_ATTRIBUTE_ARCHIVE);
    }

// Operations
    BOOL FindFile(LPCTSTR pstrName = NULL)
    {
        Close();

        if(pstrName == NULL)
        {
            pstrName = _T("*.*");
        }
        else if(lstrlen(pstrName) >= MAX_PATH)
        {
            ATLASSERT(FALSE);
            return FALSE;
        }

        SecureHelper::strcpy_x(m_fd.cFileName, _countof(m_fd.cFileName), pstrName);

        m_hFind = ::FindFirstFile(pstrName, &m_fd);

        if(m_hFind == INVALID_HANDLE_VALUE)
            return FALSE;

#ifndef _WIN32_WCE
        bool bFullPath = (::GetFullPathName(pstrName, MAX_PATH, m_lpszRoot, NULL) != 0);
#else // CE specific
        errno_t nRet = SecureHelper::strncpy_x(m_lpszRoot, _countof(m_lpszRoot), pstrName, _TRUNCATE);
        bool bFullPath = (nRet == 0 || nRet == STRUNCATE);
#endif // _WIN32_WCE

        // passed name isn't a valid path but was found by the API
        ATLASSERT(bFullPath);
        if(!bFullPath)
        {
            Close();
            ::SetLastError(ERROR_INVALID_NAME);
            return FALSE;
        }
        else
        {
            // find the last forward or backward whack
            LPTSTR pstrBack  = MinCrtHelper::_strrchr(m_lpszRoot, _T('\\'));
            LPTSTR pstrFront = MinCrtHelper::_strrchr(m_lpszRoot, _T('/'));

            if(pstrFront != NULL || pstrBack != NULL)
            {
                if(pstrFront == NULL)
                    pstrFront = m_lpszRoot;
                if(pstrBack == NULL)
                    pstrBack = m_lpszRoot;

                // from the start to the last whack is the root

                if(pstrFront >= pstrBack)
                    *pstrFront = _T('\0');
                else
                    *pstrBack = _T('\0');
            }
        }

        m_bFound = TRUE;

        return TRUE;
    }

    BOOL FindNextFile()
    {
        ATLASSERT(m_hFind != NULL);

        if(m_hFind == NULL)
            return FALSE;

        if(!m_bFound)
            return FALSE;

        m_bFound = ::FindNextFile(m_hFind, &m_fd);

        return m_bFound;
    }

    void Close()
    {
        m_bFound = FALSE;

        if(m_hFind != NULL && m_hFind != INVALID_HANDLE_VALUE)
        {
            ::FindClose(m_hFind);
            m_hFind = NULL;
        }
    }
};


// Global functions for stock GDI objects

inline HPEN AtlGetStockPen(int nPen)
{
#if (_WIN32_WINNT >= 0x0500) && !defined(_WIN32_WCE)
    ATLASSERT(nPen == WHITE_PEN || nPen == BLACK_PEN || nPen == NULL_PEN || nPen == DC_PEN);
#else
    ATLASSERT(nPen == WHITE_PEN || nPen == BLACK_PEN || nPen == NULL_PEN);
#endif
    return (HPEN)::GetStockObject(nPen);
}

inline HBRUSH AtlGetStockBrush(int nBrush)
{
#if (_WIN32_WINNT >= 0x0500) && !defined(_WIN32_WCE)
    ATLASSERT((nBrush >= WHITE_BRUSH && nBrush <= HOLLOW_BRUSH) || nBrush == DC_BRUSH);
#else
    ATLASSERT(nBrush >= WHITE_BRUSH && nBrush <= HOLLOW_BRUSH);
#endif
    return (HBRUSH)::GetStockObject(nBrush);
}

inline HFONT AtlGetStockFont(int nFont)
{
#ifndef _WIN32_WCE
    ATLASSERT((nFont >= OEM_FIXED_FONT && nFont <= SYSTEM_FIXED_FONT) || nFont == DEFAULT_GUI_FONT);
#else // CE specific
    ATLASSERT(nFont == SYSTEM_FONT);
#endif // _WIN32_WCE
    return (HFONT)::GetStockObject(nFont);
}

inline HPALETTE AtlGetStockPalette(int nPalette)
{
    ATLASSERT(nPalette == DEFAULT_PALETTE); // the only one supported
    return (HPALETTE)::GetStockObject(nPalette);
}


// Global function for compacting a path by replacing parts with ellipsis

// helper for multi-byte character sets
inline bool _IsDBCSTrailByte(LPCTSTR lpstr, int nChar)
{
#ifndef _UNICODE
    int i = nChar;
    for( ; i > 0; i--)
    {
        if(!::IsDBCSLeadByte(lpstr[i - 1]))
            break;
    }
    return ((nChar > 0) && (((nChar - i) & 1) != 0));
#else // _UNICODE
    lpstr; nChar;
    return false;
#endif // _UNICODE
}

inline bool AtlCompactPath(LPTSTR lpstrOut, LPCTSTR lpstrIn, int cchLen)
{
    ATLASSERT(lpstrOut != NULL);
    ATLASSERT(lpstrIn != NULL);
    ATLASSERT(cchLen > 0);

    LPCTSTR szEllipsis = _T("...");
    const int cchEndEllipsis = 3;
    const int cchMidEllipsis = 4;

    if(lstrlen(lpstrIn) < cchLen)
    {
        SecureHelper::strcpy_x(lpstrOut, cchLen, lpstrIn);
        return true;
    }

    lpstrOut[0] = 0;

    // check if the separator is a slash or a backslash
    TCHAR chSlash = _T('\\');
    for(LPTSTR lpstr = (LPTSTR)lpstrIn; *lpstr != 0; lpstr = ::CharNext(lpstr))
    {
        if((*lpstr == _T('/')) || (*lpstr == _T('\\')))
            chSlash = *lpstr;
    }

    // find the filename portion of the path
    LPCTSTR lpstrFileName = lpstrIn;
    for(LPCTSTR pPath = lpstrIn; *pPath; pPath = ::CharNext(pPath))
    {
        if((pPath[0] == _T('\\') || pPath[0] == _T(':') || pPath[0] == _T('/'))
                && pPath[1] && pPath[1] != _T('\\') && pPath[1] != _T('/'))
            lpstrFileName = pPath + 1;
    }
    int cchFileName = lstrlen(lpstrFileName);

    // handle just the filename without a path
    if(lpstrFileName == lpstrIn && cchLen > cchEndEllipsis)
    {
        bool bRet = (SecureHelper::strncpy_x(lpstrOut, cchLen, lpstrIn, cchLen - cchEndEllipsis - 1) == 0);
        if(bRet)
        {
#ifndef _UNICODE
            if(_IsDBCSTrailByte(lpstrIn, cchLen - cchEndEllipsis))
                lpstrOut[cchLen - cchEndEllipsis - 1] = 0;
#endif // _UNICODE
            SecureHelper::strcat_x(lpstrOut, cchLen, szEllipsis);
        }
        return bRet;
    }

    // handle just ellipsis
    if((cchLen < (cchMidEllipsis + cchEndEllipsis)))
    {
        for(int i = 0; i < cchLen - 1; i++)
            lpstrOut[i] = ((i + 1) == cchMidEllipsis) ? chSlash : _T('.');
        lpstrOut[cchLen - 1] = 0;
        return true;
    }

    // calc how much we have to copy
    int cchToCopy = cchLen - (cchMidEllipsis + cchFileName) - 1;

    if(cchToCopy < 0)
        cchToCopy = 0;

#ifndef _UNICODE
    if(cchToCopy > 0 && _IsDBCSTrailByte(lpstrIn, cchToCopy))
        cchToCopy--;
#endif // _UNICODE

    bool bRet = (SecureHelper::strncpy_x(lpstrOut, cchLen, lpstrIn, cchToCopy) == 0);
    if(!bRet)
        return false;

    // add ellipsis
    SecureHelper::strcat_x(lpstrOut, cchLen, szEllipsis);
    TCHAR szSlash[2] = { chSlash, 0 };
    SecureHelper::strcat_x(lpstrOut, cchLen, szSlash);

    // add filename (and ellipsis, if needed)
    if(cchLen > (cchMidEllipsis + cchFileName))
    {
        SecureHelper::strcat_x(lpstrOut, cchLen, lpstrFileName);
    }
    else
    {
        cchToCopy = cchLen - cchMidEllipsis - cchEndEllipsis - 1;
#ifndef _UNICODE
        if(cchToCopy > 0 && _IsDBCSTrailByte(lpstrFileName, cchToCopy))
            cchToCopy--;
#endif // _UNICODE
        bRet = (SecureHelper::strncpy_x(&lpstrOut[cchMidEllipsis], cchLen - cchMidEllipsis, lpstrFileName, cchToCopy) == 0);
        if(bRet)
            SecureHelper::strcat_x(lpstrOut, cchLen, szEllipsis);
    }

    return bRet;
}

}; // namespace WTL

#endif // __ATLMISC_H__