summaryrefslogtreecommitdiffstats
path: root/third_party/wtl/include/atlmisc.h
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/wtl/include/atlmisc.h')
-rw-r--r--third_party/wtl/include/atlmisc.h4018
1 files changed, 4018 insertions, 0 deletions
diff --git a/third_party/wtl/include/atlmisc.h b/third_party/wtl/include/atlmisc.h
new file mode 100644
index 0000000..8c7696b
--- /dev/null
+++ b/third_party/wtl/include/atlmisc.h
@@ -0,0 +1,4018 @@
+// 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 cgit v1.1 at 2025-01-20 18:50:00 +0000