Logo Search packages:      
Sourcecode: chromium-browser version File versions  Download package

atlmisc.h

// Windows Template Library - WTL version 8.0
// Copyright (C) Microsoft Corporation. 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 Permissive License (Ms-PL) which can be found in the file
// Ms-PL.txt at the root of this distribution.

#ifndef __ATLMISC_H__
#define __ATLMISC_H__

#pragma once

#ifndef __cplusplus
      #error ATL requires C++ compilation (use a .cpp suffix)
#endif

#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:
//   AtlLoadAccelerators()
//   AtlLoadMenu()
//   AtlLoadBitmap()
//   AtlLoadSysBitmap()
//   AtlLoadCursor()
//   AtlLoadSysCursor()
//   AtlLoadIcon()
//   AtlLoadSysIcon()
//   AtlLoadBitmapImage()
//   AtlLoadCursorImage()
//   AtlLoadIconImage()
//   AtlLoadSysBitmapImage()
//   AtlLoadSysCursorImage()
//   AtlLoadSysIconImage()
//   AtlLoadString()
//
//   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 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 + 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') && lpsz[1] == _T('6') && lpsz[2] == _T('4'))
                  {
                        lpsz += 3;
                        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;
            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;
            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];
            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 (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 (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 const TCHAR* _cstrrchr(const TCHAR* p, TCHAR ch)
      {
            const TCHAR* lpsz = NULL;
            while (*p != 0)
            {
                  if (*p == ch)
                        lpsz = p;
                  p = ::CharNext(p);
            }
            return lpsz;
      }

      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 _cstrisdigit(TCHAR ch)
      {
            WORD type;
            GetStringTypeEx(GetThreadLocale(), CT_CTYPE1, &ch, 1, &type);
            return (type & C1_DIGIT) == C1_DIGIT;
      }

      static int _cstrisspace(TCHAR ch)
      {
            WORD type;
            GetStringTypeEx(GetThreadLocale(), CT_CTYPE1, &ch, 1, &type);
            return (type & C1_SPACE) == C1_SPACE;
      }

      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
      }

      static int _cstrtoi(const TCHAR* nptr)
      {
            int c;       // current char
            int total;   // current total
            int sign;    // if '-', then negative, otherwise positive

            while (_cstrisspace(*nptr))
                  ++nptr;

            c = (int)(_TUCHAR)*nptr++;
            sign = c;   // save sign indication
            if (c == _T('-') || c == _T('+'))
                  c = (int)(_TUCHAR)*nptr++;   // skip sign

            total = 0;

            while (_cstrisdigit((TCHAR)c))
            {
                  total = 10 * total + (c - '0');   // accumulate digit
                  c = (int)(_TUCHAR)*nptr++;        // get next char
            }

            if (sign == '-')
                  return -total;
            else
                  return total;   // return result, negated if necessary
      }
#else // !_ATL_MIN_CRT
      static const TCHAR* _cstrchr(const TCHAR* p, TCHAR ch)
      {
            return _tcschr(p, ch);
      }

      static const TCHAR* _cstrrchr(const TCHAR* p, TCHAR ch)
      {
            return _tcsrchr(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 _cstrisdigit(TCHAR ch)
      {
            return _istdigit(ch);
      }

      static int _cstrisspace(TCHAR ch)
      {
            return _istspace((_TUCHAR)ch);
      }

      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

      static int _cstrtoi(const TCHAR* nptr)
      {
            return _ttoi(nptr);
      }
#endif // !_ATL_MIN_CRT

      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);
            ATL::CRegKey rkParent;
            ATL::CRegKey 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;
#if (_ATL_VER >= 0x0700)
            lRet = rk.QueryDWORDValue(pT->GetRegCountName(), dwRet);
#else
            lRet = rk.QueryValue(dwRet, pT->GetRegCountName());
#endif
            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);
#if (_ATL_VER >= 0x0700)
                  ULONG ulCount = t_cchItemLen;
                  lRet = rk.QueryStringValue(szBuff, szRetString, &ulCount);
#else
                  DWORD dwCount = t_cchItemLen * sizeof(TCHAR);
                  lRet = rk.QueryValue(szRetString, szBuff, &dwCount);
#endif
                  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
            ATL::CRegKey rkParent;
            ATL::CRegKey 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;

#if (_ATL_VER >= 0x0700)
            lRet = rk.SetDWORDValue(pT->GetRegCountName(), m_nMaxEntries);
#else
            lRet = rk.SetValue(m_nMaxEntries, pT->GetRegCountName());
#endif
            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);
#if (_ATL_VER >= 0x0700)
                  lRet = rk.SetStringValue(szBuff, szDocName);
#else
                  lRet = rk.SetValue(szDocName, szBuff);
#endif
                  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;
            for(nInsertPoint = 0; nInsertPoint < nItems; nInsertPoint++)
            {
                  CMenuItemInfo mi;
                  mi.fMask = MIIM_ID;
                  ::GetMenuItemInfo(m_hMenu, nInsertPoint, TRUE, &mi);
                  if (mi.wID == t_nFirstID)
                        break;
            }
            ATLASSERT(nInsertPoint < nItems && "You need a menu item with an ID = t_nFirstID");

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

            TCHAR szItemText[t_cchItemLen + 6] = { 0 };   // add space for &, 2 digits, and a space
            int nSize = m_arrDocs.GetSize();
            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  = (LPTSTR)_cstrrchr(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  = (LPTSTR)_cstrrchr(m_lpszRoot, _T('\\'));
                  LPTSTR pstrFront = (LPTSTR)_cstrrchr(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;
            }
      }

// Helper
      static const TCHAR* _cstrrchr(const TCHAR* p, TCHAR ch)
      {
#ifdef _ATL_MIN_CRT
            const TCHAR* lpsz = NULL;
            while (*p != 0)
            {
                  if (*p == ch)
                        lpsz = p;
                  p = ::CharNext(p);
            }
            return lpsz;
#else // !_ATL_MIN_CRT
            return _tcsrchr(p, ch);
#endif // !_ATL_MIN_CRT
      }
};


///////////////////////////////////////////////////////////////////////////////
// Global functions for loading resources

inline HACCEL AtlLoadAccelerators(ATL::_U_STRINGorID table)
{
      return ::LoadAccelerators(ModuleHelper::GetResourceInstance(), table.m_lpstr);
}

inline HMENU AtlLoadMenu(ATL::_U_STRINGorID menu)
{
      return ::LoadMenu(ModuleHelper::GetResourceInstance(), menu.m_lpstr);
}

inline HBITMAP AtlLoadBitmap(ATL::_U_STRINGorID bitmap)
{
      return ::LoadBitmap(ModuleHelper::GetResourceInstance(), bitmap.m_lpstr);
}

#ifdef OEMRESOURCE
inline HBITMAP AtlLoadSysBitmap(ATL::_U_STRINGorID bitmap)
{
#ifdef _DEBUG
      WORD wID = (WORD)bitmap.m_lpstr;
      ATLASSERT(wID >= 32734 && wID <= 32767);
#endif // _DEBUG
      return ::LoadBitmap(NULL, bitmap.m_lpstr);
}
#endif // OEMRESOURCE

inline HCURSOR AtlLoadCursor(ATL::_U_STRINGorID cursor)
{
      return ::LoadCursor(ModuleHelper::GetResourceInstance(), cursor.m_lpstr);
}

inline HCURSOR AtlLoadSysCursor(LPCTSTR lpCursorName)
{
#if (WINVER >= 0x0500)
      ATLASSERT(lpCursorName == IDC_ARROW || lpCursorName == IDC_IBEAM || lpCursorName == IDC_WAIT ||
            lpCursorName == IDC_CROSS || lpCursorName == IDC_UPARROW || lpCursorName == IDC_SIZE ||
            lpCursorName == IDC_ICON || lpCursorName == IDC_SIZENWSE || lpCursorName == IDC_SIZENESW ||
            lpCursorName == IDC_SIZEWE || lpCursorName == IDC_SIZENS || lpCursorName == IDC_SIZEALL ||
            lpCursorName == IDC_NO || lpCursorName == IDC_APPSTARTING || lpCursorName == IDC_HELP ||
            lpCursorName == IDC_HAND);
#else // !(WINVER >= 0x0500)
      ATLASSERT(lpCursorName == IDC_ARROW || lpCursorName == IDC_IBEAM || lpCursorName == IDC_WAIT ||
            lpCursorName == IDC_CROSS || lpCursorName == IDC_UPARROW || lpCursorName == IDC_SIZE ||
            lpCursorName == IDC_ICON || lpCursorName == IDC_SIZENWSE || lpCursorName == IDC_SIZENESW ||
            lpCursorName == IDC_SIZEWE || lpCursorName == IDC_SIZENS || lpCursorName == IDC_SIZEALL ||
            lpCursorName == IDC_NO || lpCursorName == IDC_APPSTARTING || lpCursorName == IDC_HELP);
#endif // !(WINVER >= 0x0500)
      return ::LoadCursor(NULL, lpCursorName);
}

inline HICON AtlLoadIcon(ATL::_U_STRINGorID icon)
{
      return ::LoadIcon(ModuleHelper::GetResourceInstance(), icon.m_lpstr);
}

#ifndef _WIN32_WCE
inline HICON AtlLoadSysIcon(LPCTSTR lpIconName)
{
#if (WINVER >= 0x0600)
      ATLASSERT(lpIconName == IDI_APPLICATION || lpIconName == IDI_ASTERISK || lpIconName == IDI_EXCLAMATION ||
                lpIconName == IDI_HAND || lpIconName == IDI_QUESTION || lpIconName == IDI_WINLOGO ||
                lpIconName == IDI_SHIELD);
#else // !(WINVER >= 0x0600)
      ATLASSERT(lpIconName == IDI_APPLICATION || lpIconName == IDI_ASTERISK || lpIconName == IDI_EXCLAMATION ||
                lpIconName == IDI_HAND || lpIconName == IDI_QUESTION || lpIconName == IDI_WINLOGO);
#endif // !(WINVER >= 0x0600)
      return ::LoadIcon(NULL, lpIconName);
}
#endif // !_WIN32_WCE

inline HBITMAP AtlLoadBitmapImage(ATL::_U_STRINGorID bitmap, UINT fuLoad = LR_DEFAULTCOLOR)
{
      return (HBITMAP)::LoadImage(ModuleHelper::GetResourceInstance(), bitmap.m_lpstr, IMAGE_BITMAP, 0, 0, fuLoad);
}

inline HCURSOR AtlLoadCursorImage(ATL::_U_STRINGorID cursor, UINT fuLoad = LR_DEFAULTCOLOR | LR_DEFAULTSIZE, int cxDesired = 0, int cyDesired = 0)
{
      return (HCURSOR)::LoadImage(ModuleHelper::GetResourceInstance(), cursor.m_lpstr, IMAGE_CURSOR, cxDesired, cyDesired, fuLoad);
}

inline HICON AtlLoadIconImage(ATL::_U_STRINGorID icon, UINT fuLoad = LR_DEFAULTCOLOR | LR_DEFAULTSIZE, int cxDesired = 0, int cyDesired = 0)
{
      return (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), icon.m_lpstr, IMAGE_ICON, cxDesired, cyDesired, fuLoad);
}

#ifdef OEMRESOURCE
inline HBITMAP AtlLoadSysBitmapImage(WORD wBitmapID, UINT fuLoad = LR_DEFAULTCOLOR)
{
      ATLASSERT(wBitmapID >= 32734 && wBitmapID <= 32767);
      ATLASSERT((fuLoad & LR_LOADFROMFILE) == 0);   // this one doesn't load from a file
      return (HBITMAP)::LoadImage(NULL, MAKEINTRESOURCE(wBitmapID), IMAGE_BITMAP, 0, 0, fuLoad);
}
#endif // OEMRESOURCE

inline HCURSOR AtlLoadSysCursorImage(ATL::_U_STRINGorID cursor, UINT fuLoad = LR_DEFAULTCOLOR | LR_DEFAULTSIZE, int cxDesired = 0, int cyDesired = 0)
{
#ifdef _DEBUG
      WORD wID = (WORD)cursor.m_lpstr;
      ATLASSERT((wID >= 32512 && wID <= 32516) || (wID >= 32640 && wID <= 32648) || (wID == 32650) || (wID == 32651));
      ATLASSERT((fuLoad & LR_LOADFROMFILE) == 0);   // this one doesn't load from a file
#endif // _DEBUG
      return (HCURSOR)::LoadImage(NULL, cursor.m_lpstr, IMAGE_CURSOR, cxDesired, cyDesired, fuLoad);
}

inline HICON AtlLoadSysIconImage(ATL::_U_STRINGorID icon, UINT fuLoad = LR_DEFAULTCOLOR | LR_DEFAULTSIZE, int cxDesired = 0, int cyDesired = 0)
{
#ifdef _DEBUG
      WORD wID = (WORD)icon.m_lpstr;
      ATLASSERT(wID >= 32512 && wID <= 32517);
      ATLASSERT((fuLoad & LR_LOADFROMFILE) == 0);   // this one doesn't load from a file
#endif // _DEBUG
      return (HICON)::LoadImage(NULL, icon.m_lpstr, IMAGE_ICON, cxDesired, cyDesired, fuLoad);
}

#if (_ATL_VER < 0x0700)
inline int AtlLoadString(UINT uID, LPTSTR lpBuffer, int nBufferMax)
{
      return ::LoadString(_Module.GetResourceInstance(), uID, lpBuffer, nBufferMax);
}
#endif // (_ATL_VER < 0x0700)

#ifdef _WIN32_WCE // CE only direct access to the resource
inline LPCTSTR AtlLoadString(UINT uID)
{
      LPCTSTR s = (LPCTSTR)::LoadString(ModuleHelper::GetResourceInstance(), uID, NULL, 0);
#ifdef DEBUG // Check for null-termination
      if(s != NULL)
            // Note: RC -n <file.rc> compiles null-terminated resource strings
            ATLASSERT(s[*((WORD*)s -1) - 1] == L'\0');
#endif
      return s;
}
#endif // _WIN32_WCE

inline bool AtlLoadString(UINT uID, BSTR& bstrText)
{
      USES_CONVERSION;
      ATLASSERT(bstrText == NULL);

      LPTSTR lpstrText = NULL;
      int nRes = 0;
      for(int nLen = 256; ; nLen *= 2)
      {
            ATLTRY(lpstrText = new TCHAR[nLen]);
            if(lpstrText == NULL)
                  break;
            nRes = ::LoadString(ModuleHelper::GetResourceInstance(), uID, lpstrText, nLen);
            if(nRes < nLen - 1)
                  break;
            delete [] lpstrText;
            lpstrText = NULL;
      }

      if(lpstrText != NULL)
      {
            if(nRes != 0)
                  bstrText = ::SysAllocString(T2OLE(lpstrText));
            delete [] lpstrText;
      }

      return (bstrText != NULL) ? true : false;
}


///////////////////////////////////////////////////////////////////////////////
// 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);
      if(!bRet)
            return false;
      TCHAR szSlash[2] = { chSlash, 0 };
      SecureHelper::strcat_x(lpstrOut, cchLen, szSlash);
      if(!bRet)
            return false;

      // 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__

Generated by  Doxygen 1.6.0   Back to index